1.继承
* 继承的优点：
* 1：提高代码的复用性
* 继承的缺点：
* 1：提高了代码的耦合性
*
* 构造方法的执行过程
* 1：创建子类对象，先去调用父类的构造方法，再调用自己构造方法
* 2：java中的顶级父类是Object
* 3：如果一个类没有继承其他类，那么它默认继承Object
* 4:无论new哪一个对象，都会先初始化Object
* 5:如果子类初始化的时候，没有给属性赋值，那么它获取的是父类的属性值，如果子类给属性赋值了，那么就会覆盖父类属性的值
* 6:初始化子类之前，一定要先初始化父类的值
* 7:构造方法不能被继承
*
* 子父类对于成员变量的处理
* 1：父类有，子类也有，获取的是子类的
* 2：父类有，子类没有，获取的是父类的
* 3：父类没有，子类有,获取的是子类的
* 4:父类没有，子类没有,编译报错
* 子父类对于成员方法的处理
* 1：父类有，子类也有，获取的是子类的
* 2：父类有，子类没有，获取的是父类的
* 3：父类没有，子类有,获取的是子类的
* 4:父类没有，子类没有,编译报错
*
*
*/
public class Test {
public static void main(String[] args) {
//创建一个人类
/*People p = new People();
System.out.println(p.getName());
System.out.println(p.getAge());
System.out.println(p.getSex());
System.out.println("--------------");
//创建一个学生类
Student stu = new Student();
stu.setName("宝强");
stu.setAge(20);
stu.setSex("男");
System.out.println(stu.getName());
System.out.println(stu.getAge());
System.out.println(stu.getSex());
System.out.println("----------------");
//创建一个老师类
Teacher t = new Teacher();
t.setName("谭老师");
t.setAge(18);
t.setSex("男");
System.out.println(t.getName());
System.out.println(t.getAge());
System.out.println(t.getSex());*/
//创建一个学生类
Student stu = new Student();
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println(stu.sex);
System.out.println(stu.id);
stu.eat();
stu.study();
/*System.out.println(stu.getName());
System.out.println(stu.getAge());
System.out.println(stu.getSex());
stu.eat(); //People 直接父类
stu.study(); //Student 自己
stu.getClass(); //Object 隐示父类
*/
}
}
2.重载
public class Test2 {
/*
* 方法重载 Overload
* 1:同一个类
* 2：方法名相同
* 3：参数列表不同
* 3.1：参数个数不同
* 3.2：参数类型不同
* 3.3：参数顺序不同
* 4：与返回值无关
*
* 方法重写 Override
* 子类重新把父类中的方法写一遍
* 1：子父类之间
* 2：返回值，方法名，参数列表必须一致
* 3：子类的访问修饰符要大于等于父类的访问修饰符
*
* 返回值，方法名，参数列表必须一致
*
*
* 父类中的哪些方法应该被重写？
* 定义在父类中那些独有的方法，每个子类应该重写那么属于这个类本身的功能的的方法
* 父类中对于每个子类功能一致的方法，不用重写
* 父类中对于每个子类功能不一致的方法，应该重写
*
*/
public static void main(String[] args) {
//创建一个老师对象
Teacher t = new Teacher();
t.eat();//子类的 重写后的方法
t.sleep(); //父类的
t.work(); //子类的 重写后的方法
System.out.println("------------------");
Student s = new Student();
s.eat();
s.sleep();
s.work();
}
}
3.this和super
/*
* this：代表当前对象的引用
* super:代表当前对象的父类引用
*
* this的用法
* 1:调用自己的成员变量
* 2:调用自己的成员方法
* 3:调用自己构造方法
*
* super的用法
*
* 1:调用父类的成员变量
* 2:调用父类的成员方法
* 3:调用父类构造方法
* super(参数);
* 如果子类构造器当中既要调用父类的构造器,还要调用自己的构造器，那么super(),就不要显示的写在代码中
*
* 注意：super()一定是构造函数的第一行代码，就算显示的没有写出来，也会默认执行
* 注意：如果子类的构造方法中没有显示的写super，那么它默认会调用父类的无参的构造方法
* 注意：super和this都不能出现在static方法中
* 注意：this可以单独使用，super不可以单独使用
*
*/
public class Son extends Father {
int a = 20;
public Son(){
//super(); //调用父类无参的构造方法
//super(200);//调用父类有参的构造方法
}
public Son(int a){
this.a =a;
}
public void show(){
System.out.println(this.a); //获取的自己的属性
this.show2();//调用的自己的方法
System.out.println(this);
// System.out.println(super); 错误
System.out.println(super.a); //获取父类的属性值
super.show2();
}
public void show2(){
System.out.println("我是子类的show2方法");
}
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
4.Object
/*
* Object：所有类的公共 的父类
* 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
* 从以下版本开始： JDK1.0
* Object的常用方法
* toString(); 将对象的引用变为字符串的
* 打印对象的变量，默认会调用Object的toString()方法
* 子类重写toString方法，把Object的方法变为自己的方法，其中的功能自己实现
*
* getClass().getName()
* @
* Integer.toHexString(hashCode()
*
* 实际开发种一般不重写toString,每个属性都提供get和set方法，代码更加灵活
*
* java设计原则
* 对修改关闭
* 对扩展开发
*
*/
public class Student {
private String name;
private int age;
private String sex;
@Override
public String toString() {
return "学生 [姓名=" + name + ", 年龄=" + age + ", 性别=" + sex + "]";
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public static void main(String[] args) {
Student stu = new Student("张三",20,"男");
System.out.println(stu.toString());
}
}