1.类的继承
1.1Java只支持单继承，不允许多重继承。
1.2可多层继承，即一个类可以继承某一个类的子类
1.3子类不继承父类的构造方法。可用语句super(参数列表) 调用父类的构造方法。
1.4子类的构造方法中没有显式地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。
2.子类对象的实例化过程 ：6个阶段;
思考：1).为什么super(…)和this(…)调用语句不能同时在一个构造函数中出现？
2).为什么super(…)或this(…)调用语句只能作为构造函数中的第一句出现？
答：以上两个问题都是一个原因，super(…)或this(…)具有优先性，谁先出现就执行谁的操作，另外一个即时再出现也会被跳过。
3覆盖父类的方法
3.1覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。
3.2如果在子类中想调用父类中的那个被覆盖的方法，我们可以用super.方法的格式 。
3.3覆盖方法时，不能用比父类中被覆盖的方法更严格的访问权限 。
4.final关键字
4.1在Java中声明类、属性和方法时，可使用。
4.2final标记的类不能被继承。
4.3final标记的方法不能被子类重写。
4.3final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
4.4方法中定义的内置类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期，将一个形参定义成final也是可以的，这就限定了我们在方法中修改形式参数的值。
4.5public static final共同标记常量时，这个常量就成了全局的常量。
5.抽象类
5.1定义：java中可以定义一些不含方法体的方法，它的方法体的实现交给该类的子类根据自己的情况去实现，这样的方法就是抽象方法，包含抽象方法的类就叫抽象类。
5.2抽象类必须用abstract关键字来修饰；抽象方法也必须用abstract来修饰。
5.3抽象类不能被实例化，也就是不能用new关键字去产生对象。
5.4抽象方法只需声明，而不需实现。
5.5含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
6接口(interface)
6.1如果一个抽象类中的所有方法都是抽象的，我们就可以将这个类用另外一种方式来定义，也就是接口定义。接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
6.2接口中的成员都是public访问类型。接口里的变量默认用public static final标识。
6.3我们可以定义一个新的接口用extends关键字去继承一个已有的接口
6.4我们也可以定义一个类用implements关键字去实现一个接口中的所有方法，我们还可以去定义一个抽象类用implements关键字去实现一个接口中定义的部分方法。
6.5一个类可以继承一个父类的同时，实现一个或多个接口，extends关键字必须位于implemnets关键字之前。
7对象的类型转换
7.1子类对象可以自动转换成父类
7.2父类转换成子类必须使用强制转换。
7.3nstanceof 操作符可以用它来判断一个实例对象是否属于一个类。
7.4Object类及equals方法
8面向对象的多态性
1).应用程序不必为每一个派生类（子类）编写功能调用，只需要对抽象基类进行处理即可。这一招叫“以不变应万变”，可以大大提高程序的可复用性。
2). 派生类的功能可以被基类的引用变量引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。以前写的程序可以被后来程序调用不足为奇，现在写的程序（如callA方法）能调用以后写的程序（以后编写的一个类A的子类， 如类D）就了不起了。
演示的代码备份1：
//类与继承的演示
class Person
{
public static final String x = "abc"; //变量刚开始时候初始赋值是可以的，也可以在构造方法中赋值，只能赋值一次；
public String name = "unknown"; //加final后就不能赋值；
public int age = -1;
public Person()
{
//x = "abc";
}
public Person(String name,int age)
{
//x = "abc";
this.name = name;
this.age = age;
}
public void getInfo() //改为private后，无法让子类调用的；加final后，子类就不能覆盖；
{
System.out.println("name="+name+",age="+age);
System.out.println(x);
}
}
class Student extends Person
{
public String school = "unkown";
public Student()
{
super();
//super("zhangsan",15);
}
public Student(String name,int age)
{
super(name,age);
}
public Student(String name,int age,String school)
{
this(name,age);
this.school = school;
//super.getInfo(); //调用父类的函数
}
public void getInfo() //改为private时候会报错，覆盖时不能降低父类函数的访问权限；
{
System.out.println("school="+school+",name="+name+",age="+age);
//super.getInfo();
}
public void study()
{
}
}
class TestStudent
{
public static void main(String [] args)
{
Student st = new Student("张三",20,"清华大学");
/*st.name = "zhangsan";
st.age = 20;*/
st.getInfo();
System.out.println(Float.MAX_VALUE);
}
}
演示的代码备份2：
//抽象类和接口定义的演示体会
interface Runner
{
int ID = 1;
void run();
}
interface Animal extends Runner
{
void breathe();
}
class Fish implements Animal
{
public void run()
{
System.out.println("fish is swiming");
}
public void breathe()
{
System.out.println("fish is bubbing");
}
public static void main(String [] args)
{
Fish f = new Fish();
int j = 0;
j = Runner.ID;
j = f.ID;
j = Fish.ID;
//f.ID = 2;
}
}
abstract class LandAnimal implements Animal //注意要加abstract定义为抽象类
{
public void breathe(){};
}
interface Flyer
{
void fly();
}
class Bird implements Runner,Flyer
{
public void run(){}
public void fly(){}
}
class Student extends Person implements Runner
{
public void run(){};
}
interface A //都是公共访问类型的,省略了public
{
int ID = 1; //省略了public static final；
int aa(int x,int y); //抽象类不能实例化；
void bb();
/*public static void main(String [] args)
{
A a = new A();
} */
}
/*class B extends A
{
int aa(int x,int y){return 1;}
}*/
演示的代码备份3：
// 强制类型转换和equals()方法的覆盖
class A
{
public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{
func1();
}
}
class B extends A
{
public void func1()
{
System.out.println("B func1 is calling");
}
public void func3()
{
System.out.println("B func3 is calling");
}
}
class C
{
public static void main(String []args)
{
B b = new B();
callA(b);
/*A a = b;
callA(new B()); */ //转换
}
public static void callA(A a)
{
/*if(a instanceof B) //做出类型判断，能万无一失；
{
B b = (B)a; //强制类型转换后才行
b.func1();
b.func2();
b.func3();
}*/
a.func1();
a.func2();
}
}
class Student //extends Object
{
private String name;
private int age;
public Student(String name,int age)
{
this.name = name;
this.age = age;
}
public boolean equals(Object obj) //覆盖才有意义；
{
Student st = null;
if(obj instanceof Student)
{
st = (Student)obj;
if(st.name == name && st.age == age)
return true;
else
return false;
}
else
return false;
}
public static void main(String [] args)
{
Student st1 = new Student("zhangsan",20);
Student st2 = new Student("zhangsan",20);
if(st1.equals(st2))
System.out.println("equals");
else
System.out.println("not equals"); //如无覆盖的equals方法，仍然会显示“equals”的结果；
}
}
扫一扫
889
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
