Java学习笔记之封装与继承

封装

1，将属性定义为私有的(private)   不能通过  对象名.属性  来直接访问，但是可以通过方法来间接的访问,

2，封装的意义:公有属性可以被随意修改，并且不能被程序察觉。封装后，别人通过方法来访问属性时，我们可以添加限制，访问可以被程序察觉。

下面我们用封装定义一个手机类（这种类一般我们称为 javabean）

public class Phone {
    private String type;
    private int price;
    private String color;
     
    public String getType(){
        return type;
    }
    public void setType(String type){
        this.type=type;
    }
    public int getPrice() {
    return price;
    }
    public void setPrice(int price) {
    this.price = price;
    }
    public String getColor() {
    return color;
    }
    public void setColor(String color) {
    this.color = color;
    }
     
}

注意  

1，类中属性和方法的定义顺序没有先后之分

2，当参数与属性重名时，计算机会优先考虑参数(这本身是错误的，不要这样做)

继承

继承：子类继承父类的几乎所有内容（属性跟方法）  关键字 extends

1，那么什么不能被继承呢？ private（私有属性）和构造方法不能被继承

2，所有类都是object的子类

3，在java中只能单继承

重写：当子类继承过来的方法不满意，重新覆盖这个方法。

1，当重写了父类的方法，调用的是子类重写过的方法，不会调用父类的那个方法。

public class Person {
     
     public void eat(){
         System.out.println("我是父类的方法吃...");
     }    
}

public class Student extends Person {
    //重写  方法名与父类相同 会覆盖父类的方法
    @Override
    public void eat() {
        System.out.println("我是子类中重写的父类方法吃...");
    }
}

public class Text {
    //我是测试类
    public static void main(String[] args) {
           Student s=new Student();
           s.eat();
    }
}
//控制台输出结果为：
//我是子类中重写的父类方法吃...

2，super  可以在子类中调用父类的方法

public class Student extends Person {
     //重写  方法名与父类相同 会覆盖父类的方法
    @Override
     public void eat() {
         //调用父类中的eat()
         super.eat()
         System.out.println("我是子类中重写的父类方法吃...");
     }
}
//若再进行测试，控制台输出结果为：
//我是父类的方法吃...
//我是子类中重写的父类方法吃...

重载：方法名与父类相同，参数列表不同 ，是根据参数列表来匹配执行哪个方法

public class Student extends Person {
     //重载  方法名与父类相同，参数列表不同
     public void eat(String s) {
         System.out.println("我是子类中重载的父类方法吃...");
     }
}


public class Text {
        //我是测试类
    public static void main(String[] args) {
           Student s=new Student();
           //参数对应就会调用相应的方法
           s.eat("sss");
        }
}
//结果为：我是子类中重载的父类方法吃...

要点：当创建子类对象的时候，会先初始化父类的对象。如果没有显示调用父类的构造方法，默认调用父类的无参的构造方法。

构造方法重载

public Student(String sex){
        System.out.println("------>sex");
        //如果没有显示调用父类的构造方法，默认调用父类的无参的构造方法。
        this.sex = sex ;
}
    
public Student(String sex,int age){
        this(sex); // this() 表示的是本类其他的构造方法，根据参数寻找是哪个构造方法。当表示其他构造方法的时候必须必须放在第一行。
        this.age = age ;
        System.out.println("------>sex age ");
}
    
    
public Student(){
        super("sssss");// 显示调用父类的构造方法，不需要方法名。当super父类构造方法的时候，必须放在第一行。
        System.out.println("-----Student的构造方法------");
}