封装:通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口。
继承:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。
继承类叫做子类,基类。 被继承的类叫做父类,派生类,或超类 在继承关系中,父类更通用、子类更具体。父类具有更一般的特征和行为,而子类除了具有父类的特征和行为,还具有一些自己特殊的特征和行为。 如果子类中重写了父类的方法,可以通过super关键字调用父类的方法。
private String name; private String sex; public xinxin1(String name,String sex) { this.name=name; this.sex=sex; } public void hello(){ System.out.println(“嗨!我是”+name+”我是”+sex+”孩”); } 子类: public xinxin2(String name,String sex) { //调用父类的构造方法 super(name,sex); } public void hello(){ System.out.println(“我是新来的!”); //调用父类的方法 super.hello(); } 复制代码
多态:形参一定是父类的引用,而实参可以是它任何一个子类的引用。
public class Animal { public void shout(){ System.out.println("吼吼......"); } } 定义一个狗类,继承自动物类,重写“叫”的方法 public class Dog extends Animal{ public void shout(){ System.out.println("汪汪"); } } 定义一个猫类 public class Cat extends Animal { public void shout() { System.out.println("喵喵"); } } 测试程序 public class Test { public static void main(String[] args) { Dog d = new Dog(); Cat c = new Cat(); hit(d); hit(c); } private static void hit(Dog d) { d.shout(); } private static void hit(Cat c) { c.shout(); } } 复制代码
byte,short,int,long,float,double,char,boolean
goto和const,但是这两个是目前无法使用的关键字,因此有些地方将其称之为保留字,其实保留字这个词应该有更广泛的意义
int是基本数据类型,integer是一个类
Math.round(11.5)的返回值是12,Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。
数组没有length()方法,有length的属性。String有length()方法
在最外层循环前加一个标记如A,然后用break A
public class Test3 { public static void main(String[] args) { method1(); method2(); } //方法一: public static void method1(){ ok:for(int i=0;i<10;i++){ for(int j=0;j<10;j++){ System.out.println("i="+i+",j="+j); if(j==5){ break ok;//跳到循环外的ok出,即终止整个循环 } } } } 复制代码
对,如果两个对象x和y满足x.equals(y) == true,它们的哈希码(hash code)应当相同。Java对于eqauls方法和hashCode方法是这样规定的:
String类是final类,不可以被继承。
方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。 重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的返回类型 ,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求。
不可以,静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化。
sleep()是Thread的静态方法,调用此方法线程会暂停执行,将CPU让给其他进程,但是对象的锁会依然保持,休眠结束后会自动恢复。
wait()是Object类的方法,调用wait()方法导致当前线程放弃对象的锁,进入对象的等待池,只有调用对象的notify()方法才能将其唤醒。
一种是继承Thread类;另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为,推荐使用后者,因为Java中的继承是单继承,一个类有一个父类,如果继承了Thread类就无法再继承其他类了,显然使用Runnable接口更为灵活。
public class MultiThread_Test { public static void main(String[] args) { MyThread mt = new MyThread(); mt.start(); } } class MyThread extends Thread { public void run() { System.out.println(Thread.currentThread().getName()); } } 复制代码
public class MultiThread_Test { public static void main(String[] args) { MyRunnable mr = new MyRunnable(); new Thread(mr).start(); } } class MyRunnable implements Runnable { public void run() { System.out.println(Thread.currentThread().getName()); } } 复制代码
class MyThread implements Runnable { private int count; public MyThread() { count = 0; } public void run() { //同步代码块中锁定的是当前实例对象 synchronized(this) { for (int i = 0; i < 5; i++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } } 复制代码
class MyThread implements Runnable { private static int count; public MyThread() { count = 0; } public synchronized static void method() { for (int i = 0; i < 5; i ++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } public void run() { method(); } } 复制代码
在面向对象编程中,创建和销毁对象是很费时间的,因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此,虚拟机将试图跟踪每一个对象,以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数,特别是一些很耗资源的对象创建和销毁,这就是”池化资源”技术产生的原因。 线程池顾名思义就是事先创建若干个可执行的线程放入一个池(容器)中,需要的时候从池中获取线程不用自行创建,使用完毕不需要销毁线程而是放回池中,从而减少创建和销毁线程对象的开销 。
无论是否发生异常,finally代码块中的关键字都会被执行,一般是运行清理收尾性质的语句。 finally代码块出现在catch语句的最后。finally中使用return是一种非常不好的编程风格,它会覆盖掉所有的返回,并且吃掉catch中的异常。
try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }finally{ // 程序代码 } 复制代码