java面向对象

封装:对类的信息通过权限修饰符进行隐藏,外界只能通过类中所提供的特定的方法来访问该信息

public class Animal {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.在JAVA中使用extends关键字来表示继承关系。

1. JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。

2. 继承具有传递性,a是b的父类,b是c的父类,那么c就拥有a和b的所有的非私有的属性和非私有方法

3. 继承之后子类可以调用父类的所有非私有属性和非私有方法

4. 继承实现了代码的复用性,提高了代码的可扩展性

5. 当一个类没有继承任何一个类的时候,java会默认让类继承object

示例(在同一个包中,不同类)

public class Test {
    public static void main(String[] args) {
        Bc bc=new Bc();
        bc.setName("奔驰x3");
        bc.setPrice(500000);
        bc.print2();
        bc.showInfo();
        BmX3 bmx3=new BmX3();
        bmx3.show();
        bmx3.print3();
        BmX3 bm=new BmX3("宝马",20000,"白色");
        bm.showInfo();
        System.out.println(bm.getColor());
    }
}
​
​
​
public class Car {
    
    private String name;
    private int price;
    //构造方法作用:初始化对象,为对象的属性赋值
   //无参构造方法
    public Car() {
        System.out.println("这是车类的无参构造方法");
    }
    //有参构造方法
    public Car(String name,int price,String color){
        this.price=price;
        this.name=name;
    }
    public void print(){
        System.out.println("车能载人");
    }
    public void showInfo(){
        System.out.println(name+"的价格为"+price);
    }
    //访问私有方法
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getPrice() {
        return price;
    }
​
    public void setPrice(int price) {
        this.price = price;
    }
​
​
}
​
​
​
​
​
public class Bc extends Car{
    public void print2(){
        System.out.println("奔驰跑得快");
    }
}
​
​
​
public class Bm extends Car {
    private String color;
​
    public Bm() {
        super();//必须放在第一行
        System.out.println("这是宝马类的无参构造方法");
    }
​
    public Bm(String name, int price, String color) {
        super(name, price, color);
        this.color = color;
    }
​
    public void print3() {
        System.out.println("宝马跑得快");
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}
​
​
​
​
public class BmX3 extends Bm{
    
    public BmX3() {
        super();
        System.out.println("这是BmX3类的无参构造方法");
    }
    public BmX3(String name,int price,String color){
        super(name,price,color);
    }
    public void show(){
        System.out.println("宝马X3耗油多");
    }
}

测试结果:

这是车类的无参构造方法 奔驰跑得快 奔驰x3的价格为500000 这是车类的无参构造方法 这是宝马类的无参构造方法 这是BmX3类的无参构造方法 宝马X3耗油多 宝马跑得快 宝马的价格为20000 白色

作用:初始化对象,为对象的属性赋值

1.调用子类的构造方法时会先调用父类的构造方法

2.使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行

作用:

1.使用super关键字访问父类成员

2.用super.成员变量名来引用父类成员变量

3.用super.方法名（参数列表）访问父类的方法

4.用super.构造方法(参数列表)访问父类构造方法

当父类的方法不满足需求时,就可以通过子类根据自己的需要对这个方法进行改造

方法重写规则:

1. 方法名相同、参数列表相同

2. 返回值类型相同

3. 访问权限不能小于父类权限

   abstract class Animal {
       int age;
       String name;
       public abstract void play();
   }
   public  class Dog extends Animal{
       @Override
       public void play() {
           System.out.println("狗可以玩耍");
       }
   }

它只有声明，而没有具体的实现.

抽象方法必须用abstract关键字进行修饰.

用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

特点:

1.抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象

2.继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类

abstract class Animal {
    int age;
    String name;
    public abstract void play();
}
public  class Dog extends Animal{
    @Override
    public void play() {
        System.out.println("狗可以玩耍");
    }
}