Java面向对象3

淡淡的烟草味﹌ 2022-06-11 02:17 236阅读 0赞

## 继承 ##

**继承的概述**

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。

**继承的格式&使用**  
在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。  
格式：  
class 子类 extends 父类 \{\}

public class ExtendsDemo { 
        public static void main(String[] args) {
            DotA1 d = new DotA1();
            d.start();
    
            LOL1 l = new LOL1();
            l.start();
        }
    }
    
    class Game1 { 
        String name;
        double version;//版本号
        String agent;//代理商
    
        public void start() {
            System.out.println("游戏启动了");
        }
    
        public void stop() {
            System.out.println("游戏关闭了");
        }
    }
    
    class DotA1 extends Game1 { 
        /*String name; double version;//版本号 String agent;//代理商 public void start() { System.out.println("游戏启动了"); } public void stop() { System.out.println("游戏关闭了"); }*/
    }
    
    class LOL1 extends Game1 { 
        /*String name; double version;//版本号 String agent;//代理商 public void start() { System.out.println("游戏启动了"); } public void stop() { System.out.println("游戏关闭了"); }*/
    
    }

**继承的特点**

Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹）  
Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）

在类的继承中，需要注意一些问题，具体如下：

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。  
class A\{\}  
class B\{\}

2、多个类可以继承一个父类，例如下面这种情况是允许的。  
class A\{\}  
class B extends A\{\}  
class C extends A\{\} // 类B和类C都可以继承类A

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。  
class A\{\}  
class B extends A\{\} // 类B继承类A，类B是类A的子类

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类

public class ExtendsDemo2 { 
        public static void main(String[] args) {
            LOL l = new LOL();
            l.update();
            l.start();
        }
    }
    
    class Game { 
        public void start() {
            System.out.println("游戏启动了");
        }
    }
    
    class PCGame extends Game { 
        public void update() {
            System.out.println("PCGame更新了");
        }
    }
    
    class MobileGame extends Game { 
        public void update() {
            System.out.println("MobileGame更新了");
        }
    }
    
    class LOL extends PCGame { 
    
    }

**继承中成员变量的特点**

*A:子类只能获取父类非私有成员*  
子父类中成员变量的名字不一样直接获取父类的成员变量  
子父类中成员变量名字是一样的获取的是子类的成员变量

*B:就近原则：谁离我近我 就用谁*  
如果有局部变量就使用局部变量  
如果没有局部变量，有子类的成员变量就使用子类的成员变量  
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量

*C: super:可以获取父类的成员变量和成员方法,用法和this是相似的*

public class ExtendsDemo3 { 
        public static void main(String[] args) {
            Kid3 k = new Kid3();
            k.show();
        }
    }
    
    class Dad3 { 
        String name = "建霖";
    }
    
    class Kid3 extends Dad3 { 
        String name = "四葱";
    
        public void show() {
            String name = "五葱";
    
            System.out.println(super.name);
            System.out.println(this.name);
            System.out.println(name);
        }
    }

**继承中成员方法的特点&方法重写**

*A:子类中没有这个方法,调用父类的*

public class ExtendsDemo4 { 
        public static void main(String[] args) {
            Kid4 k = new Kid4();
            k.eat();
        }
    }
    
    class Dad4 { 
        public void eat() {
            System.out.println("小酌两口");
            System.out.println("去睡觉了");
        }
    }
    
    class Kid4 extends Dad4 { 
    
    }

*B: 子类中重写了这个方法，调用子类的方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法*

**方法重写的应用场景&注意事项**

*方法重写的注意事项：*
            不可以重写父类私有的成员方法，压根就看不到父类的私有成员
            子类重写父类方法，权限必须大于等于父类方法的权限
    
    *注解*
            @Override：方法重写，说明下面的方法是重写父类的方法

public class ExtendsDemo5 { 
        public static void main(String[] args) {
            NewPhone np = new NewPhone();
            np.call();
        }
    }
    
    class Phone { 
        void call() {
            System.out.println("打电话");
        }
    }
    
    class NewPhone extends Phone { 
    
        @Override
        public void call() {
            System.out.println("录音");
            //System.out.println("打电话");
    
            //super.call();
        }
    }

**继承中构造方法的执行顺序**

A:super(实参列表);语句  在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用
    
    B:this(实参列表); 语句  在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用

public class ExtendsDemo6 { 
        public static void main(String[] args) {
            //Die d = new Die();
            Zi6 z = new Zi6();
        }
    }
    
    class Die6 { 
        public Die6() {
            System.out.println("我是父类无参构造");
        }
    
        public Die6(int num) {
            System.out.println("我是父类有参构造");
        }
    }
    
    class Zi6 extends Die6 { 
        public Zi6() {
            //super(1);
            //super();
    
            this(1);//不会再调用父类的无参构造了
    
            System.out.println("我是子类无参构造");
        }
    
        public Zi6(int num) {
            //会默认调用父类无参构造
            System.out.println("我是子类有参构造");
        }
    }

**this与super区别**

this:当前对象的引用
            调用子类的成员变量
            调用子类的成员方法
            在子类的构造方法第一行调用子类其他构造方法
        super:子类对象的父类引用
            调用父类的成员变量
            调用父类的成员方法
            在子类的构造方法第一行调用父类的构造方法

public class ExtendsDemo7 {
        public static void main(String[] args) {
            Zi z = new Zi();
            z.function();
        }
    }
    
    class Die {
        int num = 10;
    
        public Die() {
            System.out.println("我是父类无参构造");
        }
    
        public Die(int num) {
            System.out.println("我是父类有参构造");
        }
    
        public void method() {
            System.out.println("我是父类的方法");
        }
    }
    
    
    class Zi extends Die {
        //int num = 30;
    
        public Zi() {
            //this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
            super();
            System.out.println("我是子类无参构造");
        }
    
        public Zi(int num) {
            System.out.println("我是子类有参构造");
        }
    
        public void method() {
            System.out.println("我是子类的方法");
        }
    
        public void function() {
            //this.num = 50;
            //System.out.println(num);
            //this.method();
    
            //super.num = 40;
            //super.method();
    
            System.out.println(this.num);
        }

**继承优缺点**

*A:优点*  
提高了代码的复用性  
提高了代码的可维护性

*B:缺点：*  
类的耦合性增强了  
开发的原则：高内聚低耦合  
内聚：就是自己完成某件事情的能力  
耦合：类与类的关系

## 匿名对象&final ##

**匿名对象定义&使用**

匿名对象即无名对象,直接使用new关键字来创建对象

public class AnonymousObejctDemo {
        public static void main(String[] args) {
            method(new Student());
    
        }
    
        public static void method(Student s) {
    
        }
    
    
    }
    
    
    class Student {
        String name;
        int age;
    
        public void study() {
            System.out.println("好好学习，高薪就业");
        }
    }

**final关键字**

final： 修饰符，可以用于修饰类、成员方法和成员变量
    final所修饰的类：不能被继承，不能有子类
    final所修饰的方法:不能被重写
    final所修饰的变量：是不可以修改的，是常量

## 抽象类 ##

**抽象类概述**

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

**抽象类的特点：**

抽象方法只能在抽象类里面
    抽象类和抽象方法必须被abstract修饰
    抽象类不能创建对象（不能实例化）
    抽象类中可以有非抽象的方法
    抽象类和类的关系也是继承
    一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类

public class AbstractDemo2 { 
        public static void main(String[] args) {
        }
    }
    
    abstract class Animal2 { 
        public abstract void eat();
    
        public void run() {
    
        }
    }
    
    class Cat2 extends Animal2 { 
    
        @Override
        public void eat() {
            // TODO Auto-generated method stub
        }
    
    }

**抽象类的成员的特点**

成员变量
            可以有成员变量
            可以有常量
        成员方法
            可以有抽象方法
            可以有非抽象方法
        构造方法
            可以有构造方法的，需要对抽象类的成员变量进行初始化

public class AbstractDemo3 {
        public static void main(String[] args) {
            Dog d = new Dog();
            d.barking();
        }
    }
    
    abstract class Animal {
        String name = "哮天犬";
        final int num = 10;
    
        public Animal() {
            System.out.println("我是抽象类的构造方法");
        }
    
        public abstract void eat();
    
        public void run() {}
    }
    
    class Dog extends Animal {
        public void barking() {
            System.out.println(name);
            System.out.println(num);
        }
    
        @Override
        public void eat() {
            // TODO Auto-generated method stub
    
        }
    }

**雇员案例**

雇员类:
    属性:姓名,编号,薪水
    行为:工作
    程序员:
    属性:姓名,编号,薪水
    行为:写代码工作
    经理:
    属性:姓名,编号,薪水,奖金
    行为:盯着程序员写代码工作

public class AbstractTest2 { 
        public static void main(String[] args) {
            Programmer p = new Programmer();
            p.work();
    
            Manager m = new Manager();
            m.work();
        }
    }
    
    abstract class Employee { 
        String name;//姓名
        String id;//id
        double pay;//薪水
    
        //工作
        public abstract void work();
    
    }
    
    class Programmer extends Employee { 
    
        @Override
        public void work() {
            System.out.println("写代码");
        }
    
    }
    
    class Manager extends Employee { 
        byte bonus;
    
        @Override
        public void work() {
            System.out.println("盯着程序员写代码");
        }
    
    }

**抽象类的细节**

*A:抽象类关键字abstract可以和哪些关键字共存?*
    1.private：
    私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起 使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
    2.final: 
    抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类
    抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写   
    3.static:
    
    *B:抽象类中是否可以不定义抽象方法?*
    是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
    
    *C:抽象类是否有构造函数?*
       有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化