java学习笔记03-封装继承抽象类多态接口

最新推荐文章于 2021-02-17 00:44:22 发布

vly521

最新推荐文章于 2021-02-17 00:44:22 发布

阅读量166

点赞数

本文链接：https://blog.csdn.net/vly521/article/details/102487369

版权

封装：在类的属性设置时使用private将数据隐藏。不允许使用a.xingming来调用数据，可以设置get和set函数来对数据进行查看和修改（在其中添加if的判断语句来控制该参数的修改权限和读取权限）。

public class vip {
    private String xingming;
    
    /*alt + insert 自动生成get和set相关代码*/

    public String getXingming() {
        return xingming;
    }

    public void setXingming(String xingming) {
        this.xingming = xingming;
    }
}

继承：继承小明继承了人类的所有东西其中包括属性和方法，子类可以对父类的东西进行重新改写；子类只能继承一个父类；父类可以被多个子类继承；
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

下面给出一个事例。

public class people {
    public int shengao = 170;
    public void  chifan(){
        System.out.println("我在吃饭");
    }
}

public class xiaoming extends people {
    private int shengao=160;
    public void chifan(){//修改继承的方法，将吃饭的方法改为吃排骨
        System.out.println("我在排骨");
    }
    public void seeshengao(){
        System.out.println("小明的身高"+this.shengao);
        System.out.println("人们的身高" + super.shengao);
    }

}

可以在子类中使用this调用子类中的参数；使用super调用父类中的参数。
需要注意的是 Java 不支持多继承，但支持多重继承。Class A 继承 Class B Class C继承B 则C就继承了A的属性和方法。
继承的特性
子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类
final关键字
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
构造器
子类不继承父类构造器
方法重写
写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

多态
A:多态概述
某一个事物，在不同时刻表现出来的不同状态。
举例： Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
B:多态前提
a:要有继承关系。
b:要有方法重写。其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();
好处：
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)

好处的示例

public class MyTest {
    public static void main(String[] args) {
        //使用多态的好处：
        //1.提高了代码的复用性，是靠继承保证的
        //2.提高了代码的扩展性。
        Animal cat = new cat();//使用多态之后的 
        MyUtils.test(cat);
        Animal dog = new Dog();//不使用多态的时候
        MyUtils.test(dog);
      /*Dog dog = new Dog();//不使用多态的时候
       MyUtils.test(dog);*/

      

    }
}
public class Animal {
    public void eat() {
        System.out.println("吃饭");
    }
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class MyUtils {
    //私有构造，外界就无法创建，该类对象
    private MyUtils() {

    }
    public static void test(Animal an) {
        //   Animal an=cat  父类引用指向子类对象
        //   Animal an=dog 父类引用指向子类对象
        //多态的方式：在调用成员方法的时候，编译看左边，运行看右边
        //面向父类或接口 编程
        an.eat();
        //an.catchMouse();
        Cat cat= (Cat) an;
        cat.catchMouse();
    }
/*不使用多态调用方法的
    public static void test(Cat cat) {
        cat.eat();
    }

    public static void test(Dog dog) {
        dog.eat();
    }

    public static void test(Tiger tiger) {
        tiger.eat();
    }

    public static void test(Mouse mouse) {
        mouse.eat();
    }
    */
}

方法调用和属性的示例

public class MyTest {
    public static void main(String[] args) {
        // 孔子装爹
        /* 孔子爹，是一名Java讲授，讲授Java特别有名，张三这个学员 慕名而来，他把孔子爹请到家里
           去给他讲授Java,这时候就剩孔子一个人在家，李四也想学Java，李四也来，孔子家里面去请孔子爹
           孔子爹不在家，孔子又不想失去这个学员，孔子经过一番乔装打扮，扮成他爹的模样，去给李四讲课
         *  孔子讲完课之后，他觉得太类了，很不容易，他要卸下装扮做回自己，玩了一把吃鸡游戏
         *
         *
         * */
        孔子爹 k爹 = new 孔子();
        System.out.println(k爹.age);//打印60
        k爹.teach();//将论语

        //向下转型，做回自己
        孔子 kz = (孔子) k爹;
        System.out.println(kz.age);//打印30
        kz.palyGame();//玩吃鸡游戏
    }

}

class 孔子爹 {
    int age = 60;

    public void teach() {
        System.out.println("讲授Java");
    }

}

class 孔子 extends 孔子爹 {
    int age = 30;

    @Override
    public void teach() {
        System.out.println("讲论语");
    }

    public void palyGame() {//子类自带方法
        System.out.println("玩吃鸡游戏");
    }
}

抽象类
抽象类的概述及其特点
A:抽象类概述
回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法

public class MyTest {
    public static void main(String[] args) {
        //abstract 抽象的 可以修饰类，修饰方法

        //1.abstract 修饰类，此类就不能直接实例化
       // Animal animal = new Animal();
        //2.abstract 修饰方法：修饰的方法，要求子类必须重写

    }
}


abstract class Animal{

    public abstract void eat();/*{
        System.out.println("吃饭");
    }*/
}

class Dog extends Animal{

   @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

class Cat extends Animal{

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

public class MyTest2 {
    public static void main(String[] args) {
        //抽象类的注意语法
        //1.一个类里面，有了抽象方法，那么这个类，必须为抽象类
        //2.一个抽象类里面，可以不可以没有抽象方法？可以
        //3.抽象类里可以有非抽象方法吗？可以
        //4.抽象类里面，有没有构造方法？有 为了在子类创建对象时完成父类数据的初始化
        //采用多态的方式来完成父类数据的初始化
        //抽象类成员变量的特点：1.可以定义成员变量，也可以定义常量
        A a = new B();
        System.out.println(a.AA);
        System.out.println(a.num);
        //抽象类，里面既可以定义抽象方法，又可以定义非抽象方法
        //抽象的方法，他是强制子类必须重写。非抽象方法 一般就是让子类继承下去用，当然子类可以重写非抽象方法
    }
}

abstract class A {
        //abstract 在方法中使用，能不能和下面的关键字一块使用
        // private abstract  矛盾 abstract 强制子类重写 private 限定后又无法重写
        // final  abstract 矛盾  abstract 强制子类重写  final 重写不了
        //  abstract static 矛盾
    int num = 20;
    public final int AA = 20;

    public A() {
        System.out.println("抽象类的空参构造执行了");
    }

    public abstract void show();

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

class B extends A {
    int num = 600;

    public B() {
        System.out.println("子类的空参构造执行了");
    }

    @Override
    public void show() {

    }

    @Override
    public void hehe() {
        super.hehe();
    }
}

接口
接口概述
继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
B:接口特点
a:接口用关键字interface表示格式: interface 接口名 {}
b:类实现接口用implements表示格式: class 类名 implements 接口名 {}
c:接口不能实例化
d:接口的子类
1. 可以是抽象类。但是意义不大。
2.可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

public class MyTest {
    public static void main(String[] args) {
        //接口：用来定义事物的一些额外的扩展的功能，将来那类事物，想要具备，这些额外的功能，就可以实现这个接口
        //定义接口的语法 interface 接口名{}
        //类  implements 接口   是实现关系
        // 这个类，可以叫做接口的子类， 这个接口 可以叫做这个类的父接口
        //接口不能实例化，接口里面没有构造方法
        //作为接口的子类，有什么要求
        //1.要求子类必须重写接口中所有的抽象方法
        //2.如果你不想重写，你这个类可以为一个抽象类，将接口中的抽象方法继承即可
    }
}
public interface Fireinterface { //定义了一个接口
        //接口中的成员特点
        //接口中的成员变量：接口中的成员变量全是公共的静态常量
        //接口中的成员方法，全部是抽象方法，，不存在非抽象方法
        //接口中没有构造方法
       public abstract void fire();//接口中的方法，前面存在默认修饰 public abstract
       public static final int NUM = 200;
      int A = 600; //接口中成员变量 前面存在默认修饰符 public static final
}
class Cat implements Fireinterface {

    public void eat() {
    }

    @Override
    public void fire() {
        System.out.println("猫学会了钻火圈");
    }
}

class Dog implements Fireinterface{

    @Override
    public void fire() {
        System.out.println("狗学会了钻火圈");
    }
}

注意：类与类的关系：继承关系 extends Java中只支持单继承
1.类与接口的关系：实现关系 implements 可以多实现一个类可以实现多个接口
2. 接口和接口之间的关系：继承关系 extends 支持多继承一个接口可以继承多个接口
3. 一个类在继承一个类时，同时也实现多个接口
示例

public class MyTest {
    public static void main(String[] args) {
       /* A:
        案例演示
        动物类：姓名，年龄，吃饭，睡觉。
        动物培训接口：跳高
                猫继承动物类
        狗继承动物类
                部分猫继承猫类并实现跳高接口
        部分狗继承狗类并实现跳高接口*/
        布鲁斯 bls = new 布鲁斯();
        an=bls;
        an.name="布鲁斯";
        an.age=58;
        System.out.println(an.name);
        System.out.println(an.age);
        an.eat();
        an.sleep();
        JumpInteface jumpInteface= bls;
        jumpInteface.jump();
    }
}
public abstract class Animal {
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
}
public interface JumpInterface {
    void jump();
}

public class Dog extends Animal{

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

    @Override
    public void sleep() {
        System.out.println("睡觉");
    }
}
public class 布鲁斯 extends Dog implements JumpInteface {
    @Override
    public void eat() {
        System.out.println("布鲁斯吃牛排");
    }

    @Override
    public void sleep() {
        System.out.println("布鲁斯睡沙发");
    }

    public void watchTV(){
        System.out.println("看电视");
    }

    @Override
    public void jump() {
        System.out.println("布鲁斯学会了跳高");
    }
}