java面向对象基础_01

续接上一篇java面向对象基础

1. 继承

对具有相同特征的不同类的提取
关键字extends
形如：public class 子类 extends 父类
特点：子类可以有父类的内容，如果子类对父类的表示不满，可以通过方法重写完成。
***子类只可以继承一个父类，java不支持多继承

好处：提高代码复用性和维护性

1.1 关键字

this和super

1.1.1 super

super.成员变量//super访问父类的成员变量
super.()
super.成员方法()

1.1.1.1 super内存图

https://www.bilibili.com/video/BV18J411W7cE?p=156&spm_id_from=pageDriver

1.1.2 this

this.成员变量//this访问本类的成员变量
this.()
this.成员方法()

1.2 构造方法

子类所有的构造方法都会默认访问父类中的无参构造方法
默认有super();
如果父类中没有无参数的构造方法，那么使用super(参数)；访问带参数的构造方法就可以了；或者父类中创建无参构造形式就可以了public leiming(){}

//构造方法
public leiming(){}//无参形式
public leiming(int age){}//带参形式

1.3 成员方法

//形如
public void method(){}

2. 多态

同一个对象，在不同时刻表现出的不同形态

示例

猫 cat = new 猫();
动物 animal = new 猫();
猫在不同时刻表现出的不同形态，就是多态

前提和体现
a.有继承/实现关系
b.有方法重写
c.有父类引用指向子类对象；譬如：动物 animal = new 猫();
d.多态的书写方法，编译时看左边也就是父类，运行时看右边，也就是子类
e.多态不能够访问子类的独有的具体的方法

2.1 问题：为何多态中成员方法和成员变量的访问方法不一样？

因为成员方法有重写，而成员变量没有

2.2 多态转型

为了解决2.多态的e问题

2.2.1 向上转型

从子到父
父类引用指向子类对象

2.2.2 向下转型

从父到子
父类引用转为子类对象

示例

public class animal {

    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class cat extends animal {

    @Override
    public void eat(){
        System.out.println("猫爱吃鱼");
    }

    public void sing(){
        System.out.println("这猫会唱歌");
    }
}

public class test {
    public static void main(String[] args) {
        animal a = new cat();//向上转型
        a.eat();

/**        cat c = new cat();
        c.eat();
        c.sing();*/
        cat c = (cat)a;//向下转型
        c.sing();
        c.eat();

    }
}

//output
猫爱吃鱼
这猫会唱歌
猫爱吃鱼

2.3 多态内存解析

多态的内存解析b站视频

3. 接口类

3.1 接口特点

a. 修饰关键字interface;形如public interface 接口名 {}、
b.类实现接口，形如：public class 类名 implements 接口名{}
c.接口不能实例化；但可以参照多态的方式，通过实现类对象实例化，这叫接口多态
i:多态的形式：具体类多态、接口多态、抽象类多态
ii：多态的前提：有继承或者实现关系、有方法重写、有父（类/接口）引用指向（子/实现）类对象
d.接口的实现类：要么重写接口中的所有抽象方法、要么本身定义为抽象类

示例

//定义接口
public interface Animal {
    //接口抽象方法
    public abstract void eat();
}

//继承接口
public class Cat implements Animal{
    //重写接口方法
    @Override
    public void eat() {
        System.out.println("cat eat fish");
    }
}

//抽象类继承接口
public abstract class Dog implements Animal{

}

public class Test {
    public static void main(String[] args) {

        //创建接口对象
        Animal animal = new Cat();
        animal.eat();//调用子类重写方法
    }
}

//output
cat eat fish

3.2 接口类成员特点

a.接口中的参数只能是常量，默认修饰符public final static
b.接口中的方法默认修饰符public abstract
c.接口中没有构造方法，因为接口主要是对行为进行抽象，是没有具体存在的；
d.一个类如果没有父类，默认继承Object超类

示例

    //这两个在接口中是等价的，参数默认修饰符public final static
    public final static String name  = "bob";
    String name  = "bob";

   // public Animal(){}//没有构造方法
  //  public void show(){}//没有构造方法
   public abstract void show();

//public class Cat implements Animal{
public class Cat extends Object implements Animal{
//默认继承Object超类，这两种书写格式是等价的
    public Animal(){
        super();
    }
}

    public abstract void eat();//方法默认修饰符public abstract
    void eat();

3.3 实现接口中定义的静态方法和默认方法

可以发现静态方法的调用使用接口名.接口中静态方法的格式就可以了，比如下例中的InterFor.run (); 默认方法在定义时要添加return关键字，否则编译时会报错

public interface InterFor {
    public static void run(){
        System.out.println ("go faster,go higher!! ");
    }

    abstract void eat();

    default String get(String aa){
        System.out.println (aa);
        return "";
    }
}

public class TestLine implements InterFor{
    @Override
    public void eat() {
        System.out.println ("----");
    }
//    private int x =10;
//    public int area(){
//        return  x*x;
//    }

    public static void move(){
        System.out.println ("move");
    }
}

//测试类
public class TestDemo {
    public static void main(String[] args) {
//        System.out.println (new TestLine ().area ());
//
        TestLine line = new TestLine ();
        line.eat ();
        InterFor.run ();
        line.get ( "shd" );
        line.move ();
        ;
      //  System.out.println (line instanceof TestLine);
    }
}

//结果展示
----
go faster,go higher!! 
shd
move

4. 抽象类

4.1 抽象类特点

a. 一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
b.而一个抽象类中可以没有抽象方法
c.抽象类的继承必定是抽象类
d.抽象类不能实例化，但是可以通过多态的方式，对子类进行实例化，又称为抽象多态
e.抽象类的子类要么重写父类的所有抽象方法，要么本身就是一个抽象类

示例

//抽象类
public abstract class Animal {
    //抽象方法
    public abstract void eat();

    public void sleep(){
        System.out.println("animal sleeping");
    }
}

public class Cat extends Animal{

    //子类重写父类的抽象方法
    @Override
    public void eat(){
        System.out.println("cat eat fish");
    }
}

//子类本身是抽象类
public abstract class Dog extends Animal{
    //public abstract void eat();
}

public class Test {
    public static void main(String[] args) {

        //创建子类对象实例
        Animal animal = new Cat();

        //调用对象方法
        animal.eat();//子类修改后的方法
        animal.sleep();//父类
    }
}

//output
cat eat fish
animal sleeping

4.2 抽象类成员特点

a.成员变量可以是常量，也可以是变量
b.可以包含构造方法。作用：用于子类访问父类数据的初始化
c.成员方法：可以有抽象方法，限定子类必须完成某些动作；也可以有非抽象方法，提高代码复用性

示例代码

package com.Abstract;
//抽象类
public abstract class Animal {
    
    //常量+变量
    private int age = 20;
    private final String address = "street 7";
    
    //无参数构造方法
    public Animal(){}
    
    //含参构造方法
    public Animal(int age){
        this.age = age;
    }
    
    //show()方法
    public void show(){
        int age = 40;
        System.out.println(age);
        System.out.println(address);
    }
    //抽象方法
    public abstract void eat();

    public void sleep(){
        System.out.println("animal sleeping");
    }
}

//output
cat eat fish
animal sleeping
40
street 7

5. 类和接口的区别

5.1 类和接口的关系

a.类与类的关系：继承关系，只能单继承，但是可以多层继承
b.类与接口得关系：实现关系。可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
c.接口与接口的关系：继承关系。可以单继承，也可以多继承。

示例

public class inter extends Object implements inter1,inter2,inter3 {//多继承
}

public interface inter3 extends inter1,inter2{//继承关系
}

5.2 抽象类与接口的区别

示例

6. 包

6.1 建包

package
手动建包：文件夹打开创建即可
自动建包：编译时输入命令

javac -d . HelloWorld.java

6.2 导包

现在idea已经可以自动导包了，达咩嘻嘻；否则需要写出所调用包的全路径；eg:s.HelloWorld.hello();
关键字import

7. 修饰符

7.1 权限修饰符

这个写过了，看这里4种权限修饰符

7.2 状态修饰符

7.2.1 final

a.可以修饰成员方法、变量、类；不可修改；被final修饰的类不可以被修改，子类不可继承不可重写，修饰变量直接变为常量
b.修饰局部变量，修饰基本类型变常量，修饰引用类型地址值不改变

7.2.2 static

a.static表示静态，可以修饰成员方法，成员变量
b.特点：被类的所有对象共享；这是判断是否是静态关键字的特点；
c.调用：通过类名调用，或者对象名调用
d.静态成员方法只能访问静态成员变量；而非静态的可以访问ALL

注意：main方法是静态的，所以一般写方法时大多会选择静态，方便main方法调用

示例：

public class person {
    String name;
    static String address;

    public void show(){
        System.out.println("name:"+name+"\n"+"address:"+address);
    }
}

public class test {
    public static void main(String[] args) {
        person p = new person();
		
		//调用
        person.address = "street 7";
        p.name = "bob";
        p.show();
    }
}

//output
name:bob
address:street 7