/*
类的继承
类的继承可以简化类的定义
java只支持单继承，不允许多重继承
可以有多层继承，即一个类可以继承其一个类的子类，如类B继承了类A,类C又可以继承类B
那么类C也间接继承了类A
子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法，
在子类的构造方法中可使用语句super(参数列表)
调用父类的构造方法
如果子类的构造方法中没有显式地调用父类构造方法，也没用使用this关键字调用重载的其它构造方法，则在产生子类的实例对象时
系统默认调用父类无参数的构造方法
子类对象的实例化过程
1 分配成员变量的存储空间并进行默认的初始化，就是用new关键字产生对象后
对类中的成员变量按第三章的表3.1的对应关系对对象中的成员变量进行初始化赋值
2 绑定构造方法参数，就是new Person(实际参数列表)中所传递进的参数赋值给构造方中的形式参数变量
3 如果有this()调用，则调用相应的重载构造方法(被调用的重载构造方法又从步骤2开始执行这些流程)
被调用的重载构造方法的执行流程结束后，回到当前构造方法，当前构造方法直接跳转到步聚6执行
4 显示或隐式追溯调用父类的构造方法(一直到Ojbect类为止，Object是所有java类的最顶层父类)
在本音后面部分有详细讲解，父类的构造方法又从步骤2开始对父类执行这些流程，父类的构造方法的执行流程结束后，回到当前构造方法，当前构造方法继承往下执行
5 进行实例变量的显示初始化扣喺，也就是执行在定义成员变量时就对其进行赋值的语句
6 执行当前构造方法的方式体中的程序代码
1):为什么super()和this()调用语句不能同时在一个构造函数中出现？
因为当在一个构造函函数中出现this()调用以后，那么去别外一个构造函数将也会直接默认或指定的super()方法
如要执行完成以后，返回到初始的构造函数还让执行super()方法时，那就又是重复操作了，无意义
所以编译也不会通过的
2):为什么super()和this()调用语句只能作为构造函数的第一句出现
如果不是作为第一句出现,编译也会出错的
如果选执行一些赋值语句，然后执行this或super()函数
那么就跟我们的执行流程相矛盾了
因为构造函数需要需要执执行this,如果没有this执行super()方法
编译器也不会让通过的
覆盖父类的方法
覆盖方法必须和被覆盖方法具有相同的方法名称，参数列表和返回值类型
如果在子类中想调用父类中那个被覆盖的方法，我们可以用super方法的格式
覆盖方法时，不能使用此父类中被覆盖的方法更严格的访问权限
final关键字
1 在java中声明类，属性和方法时，可以使用关键字final来修饰
2 final标记的类不能被继承
3 final标记的方法不能被子类重写
4 final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次
5 方法中定义的内置类只能访问该方法内的final类型的局部变量
用final定义的局部变量相当于是一个常量，它的生命周期超出了方法运行的重命周期
将一个行参定义成final也是可以的，这就是限定了我们在方法中修改形式参数的值
6 public static final共同标记常量时，这个常量就成了全局常量
抽象类
java中可以定义一些不含方法体的方法，它的方法体的实现交给该类的子类根据自己的情况去实现
这样的方法就是抽象方法，包含抽象方法的类叫做抽象类
1 抽象类必须使用abstract关键字来修饰，抽象方法也必须用abstract来修饰
2 抽象类不能被实例化，也就是不能用new关键字去产生对象
3 抽象类只需声明，而不需实现
4 含有抽象方法的类必须声明为抽象类，抽象类的子类必须覆盖所有抽象方法后才能被实例化，否则这个子类还是个抽象类
*/
//final class Person 将不能被继承了
class Person
{
//protected final String name = "unknown"; 变量为final时将不能被子类赋值了
protected String name = "unknown";
//public final String x = "abc"; //第一种赋值是初始赋值
public final String x;
//public static final String x;
public static final String y = "abc";
public int age = -1;
public Person()
{
this.x = "cde";
}
public Person(String name, int age)
{
this.name = name;
this.age = age;
//或者在构造函数中进行赋值
this.x = "abc";
}
//public void getInfo(){} 将不能在子类重写了
public void getInfo()
{
//this.x = "abc"; //用final定义的变量将不能被修改了
System.out.println("name:"+name+", age:"+age);
}
};
class Student extends Person
{
public String school = "unknown";
public Student()
{
//super("xlc",15);
super();
}
public Student(String name, int age, String school)
{
this(name,age); //调用自己的构造函数
this.school = school;
//this(name,age); //调用自己的构造函数
}
public Student(String name, int age)
{
super(name, age);
}
public void getInfo()
{
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();
//st.name = "xlc";
//st.age = 34;
//st.getInfo();
Student st = new Student("xlc",22,"清华大学");
st.getInfo();
System.out.println(Float.MAX_VALUE);
}
};
/*
接口(interface)
如果一个抽象类中的所有方法都是抽象的，我们就可以将这个类用另外一种方式来定义，也就是接口定义
接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种特殊的抽象类
这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现
1 接口中的成员都是public访问类型的，接口的变量默认是用public static final标识的
2 我们可以定义一个新的接口用extends 关键字去继承一个已有的接口
3 我们也可以定义一个类用implements关键字去实现一个接口中的所有方法，我们还可以去定义一个抽旬类用implements关键字去实现一个接口中定义的部分方法
4 一个类可以继承一个父类的同时，实现一个或多个接口，extneds关键字必须位于implements关键字之前
对象的类型转换
1 子类对象可以自动转换成父类
2 父类转换为子类必须使用强制转换
3 instanceof操作符可以用它来判断一个实例对象是否属于一个类
4 Object类及equals方法
*/
/*abstract class A
{
abstract int aa(int x, int y);
//抽象类将不能实例化
};
class B extends A
{
int aa(int x, int y)
{
return 1;
}
};*/
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 swimming");
}
//public void breathe()
public void breathe()
{
System.out.println("fish is bubbling");
}
public static void main(String[] args)
{
Fish f = new Fish();
int j=0;
j = Runner.ID;
j = f.ID;
//f.ID = 2; //常量不能被赋值
}
};
abstract class LandAnimal implements Animal
{
public void breathe()
{
}
};
interface dog
{
void uaau();
}
interface Flyer
{
void fly();
}
class Bird implements Runner, Flyer
{
public void run()
{
}
public void fly()
{
}
};
//继承一个类时，可以实现其它接口
//也是可以继承从外接口类的
class Student extends Person implements Runner, dog
//如果继承类和接口，extends必须在implements之前
{
public void run()
{
}
public void uaau()
{
}
};
interface A
{
//public static final int ID=1;
//int ID = 1; //这个是一个常量而不是一个变量，接口只能定义常量，不能定义变量,
//只能定义常量和抽象类
public static final int ID=1;
int aa(int x, int y);
void bb();
}
/*class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}*/
/*
面向对象的多态性
1):应用程序不必为每一个派生类（子类）编写功能调用
只需要对抽象基类进行处理即可，这一招叫"以不变应万变"，可以大大提高程序的可复用性
2):派生类的功能可以被基类的引用变量引用，这叫向后兼容，可提高程序的可扩充性和可维护性
以前写的程序可以被后来程序调用不足以为奇，现在写的程序(如callA方法)能调用以后写的程序(以后编写的一个类A的子类，如类D)就了不起了
*/
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 aa = b;
//callA(new A());
}
public static void callA(A a)
{
/*if(a instanceof B)
{
B b = (B)a; //强制类型转换
b.func1();
b.func2();
b.func3();
}else{
a.func1();
a.func2();
}*/
a.func1();
a.func2();
//a.func1();
//a.func2();
//a.func3();
}
};
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;
}
}*/
//如果没有覆盖父类的equals方法，那么将返回不等
//只是重载了一下函数
public static void main(String[] args)
{
Student st1 = new Student("张三",20);
Student st2 = new Student("张三",20);
if(st1.equals(st2))
{
System.out.println("相等");
}else{
System.out.println("不相等");
}
}
};
/*class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}*/
interface PCI
{
void start();
void stop();
}
class NetWrokCard implements PCI
{
public void start()
{
System.out.println("Send...");
}
public void stop()
{
System.out.println("stop...");
}
};
class SoundCard implements PCI
{
public void start()
{
System.out.println("du...");
}
public void stop()
{
System.out.println("sound stop...");
}
};
class MainBoard
{
public void usePCICard(PCI p)
{
p.start();
p.stop();
}
};
class Assembler
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
NetWrokCard nc = new NetWrokCard();
SoundCard sc = new SoundCard();
mb.usePCICard(nc);
mb.usePCICard(sc);
//匿名类
/*mb.usePCICard(
new PCI()
{
public void start()
{
System.out.println("test start...");
}
public void stop()
{
System.out.println("test end...");
}
}
);*/
//类拟于
class A implements PCI
{
public void start()
{
System.out.println("test start...");
}
public void stop()
{
System.out.println("test end...");
}
};
mb.usePCICard(new A());
}
};