java入门基础---1.5---继承及访问权限修饰符

小梁同学 の

Java学习旅途

你好！ 这是小梁同学使用 博客 所记录的文章笔记，作为一个初学者的从基础到未来的记录，如果你想和我一起在Java学习路程上坚持下去，欢迎你的关注与指正。

新的将来

万丈高楼平地起，未来只能靠自己
从无到有，从零到一，学习路上没有尽头
每日一文，每日一记，跟着软件向前努力
加油！！！！！

详解代码均在以下标题后的链接中

以下所有有关代码，都是个人在上完课后自己重新敲代码之后所做笔记后上传，并非原搬直接上传，谢谢理解

九.继承

1.extends和super（）

冗余代码提取后，只是完成了一次定义，原来的类没有属性

//多次使用，建立类和类之间的关系
//原来的类（Cat dog 自己独特的特征）   继承  抽离出来的类（Animal 共同的特征）
//通过extends指定父类
public class Cat extends Animal{
    private String type;
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public void run(){
        System.out.println(super.getName()+"猫可以追着老鼠跑");
//     用到了父类中的属性,通过super调用父类中的方法,进行数据获取
//     super 要调用的方法从哪来的=========>super方法父类的方法
//     方法调用时有就近原则:
//     如果调用方法,再当前自己的类中找方法,如果存在,调用当前自己类的方法
//     如果调用方法,再自己类中没有,找父类的方法,父类没有,父类的父类,
//     找到Object,还是没有调用的方法,方法不存在,调用失败
//     子类中调用的方法,自己当前类中存在,如果要调用父类的方法,super不能省略
    }
}
public class Dog extends Animal{
    private String color;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}
public class Rabbit extends Animal{
    private int weight;
    public int getWeight() {
        return weight;
    }
    public void setWeight(int weight) {
        this.weight = weight;
    }
}
public class Animal {
    private String name;
    private int age;public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
public class Test1 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("tomcat");
        c.setType("加菲猫");
        c.setAge(2);
        c.run();

        Dog d = new Dog();
        d.setColor("黑色");
        d.setName("旺财");
        d.setAge(1);

        Rabbit r = new Rabbit();
        r.setWeight(2);
        r.setName("兔八哥");
        r.setAge(3);
    }
}

2.构造方法赋值

父类写了有参构造方法，子类构造方法出错，没有默认的构造方法（无参的构造）

父类中写了有参的构造方法，默认的无参的失效，子类调用了父类的无参构造方法

父类中没有方法，所以报错，子类的构造方法，默认调用父类的无参构造方法

super()只能调用父类的构造方法，如果没有要调用的构造方法，会出错（不会越级）

//指定调用的构造方法
public class Animal {
    //父类存在的构造方法
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    //有继承的类的话，因为指定了构造方法，无参构造方法失效，所以要重新构造无参方法，其余继承类才不报错
    public Animal(){
        }
}
public class Cat extends Animal{
	public Cat(String name,int age,String type){
        //super()调用父类的构造方法
        super(name, age);
        this.type=type;
    }
}    

3.父类和子类

1.super和super() 位置关系；

super 调用父类的方法或者变量，super可以放在方法的任意位置上

super()调用的父类的构造方法，只能放在构造方法第一句

在一个构造方法中，this()与super()不能同时存在

2.父类和子类表示的数据范围：

//父类类型的变量接收了子类对象
//大范围接收小范围的数据类型=======》直接转换
//Cat a = new Cat();===>Animal b = a;
Animal a1 = new Cat();
//a1.setType("sdffd")中会报错
    
Animal a1 = new Cat("tomcat",1,"加菲猫");
//a1 是Animal类型 ，
//只能调用Animal中的方法和object中方法
//setType 存在于Cat类型，处于Animal下面，所以不能调用
//创建Cat的对象 ，不能因为不能给type属性赋值，就说对象没有type的属性，属性在类中进行书写,属性存在，但是父类的对象不能调用这个方法
//子类基于父类扩展的功能，对于父类来说，是隐藏的
//向上转型，隐藏子类扩展的功能



//创建了对象，也给属性赋值了
//创建的对象有没有成功赋值，打印
//动态绑定；程序运行时，自动识别变量中存放的对象的实际类型
//        找到实际类型中的方法，进行方法的调用
        Animal a1 = new Cat("tomcat",1,"加菲猫");
        System.out.println(a1);
==============================
    Cat{type='加菲猫'}Animal{name='tomcat',age=1}

3.子类和父类：

书写的顺序：先子类后父类

先写子类，子类有重复的属性和方法，提取的父类

存在的顺序：先有父类，再有子类

父类，基类，超类

子类，扩展类，子类基于父类进行的扩展，父类有共同的特征，子类在原来特征的基础上

添加了自己独特的特征（独特的：type形成了 Cat，独特的：color形成了 Dog）

4.向上转型应用场景

print(new Cat());
print(new Dog());
print(new Fish());
print(new Rabbit());
public static void print(Animal c){
//        输出的逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        System.out.println("===============");
        System.out.println(c);//toString()
        System.out.println("**************");
    }

向上转型：

​ 1 赋值的方式：例如：Animal a = new Cat();

​ 2 传参的方式：

print(new Cat());
public static void print(Animal c)

5.方法重写

1.普通重写

在一个子类中，可以重写父类中的方法，方法符合自己类的行为方式，

如果Animal的子类特别多，有的类中，可能忘了写eat方法，忘了重写

普通方法：

​ 1 方法的声明 public 返回值 方法名（）

​ 2 方法体：{} 方法逻辑代码

public class Animal {
    public void eat(){
        System.out.println("动物可以吃")；
    }
}
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫可以抓老鼠")；
    }
}
public static void print(Animal c){
//        输出的逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        System.out.println("===============");
        c.eat()
        System.out.println("**************");
}
public static void main(String[] args){
    print(new Cat());
}
================================
    ===============
    猫可以抓老鼠
    **************

2.强制重写

执行时，输出的还是父类方法的逻辑，不符合每个类的行为方式

父类类型接收子类对象，父类调用方法

子类强制重写，（不写就报错）====抽象方法

**抽象方法：**只有方法声明，没有方法体，abstract，抽象关键词

抽象方法一定要存在于抽象类中

抽象类中不一定有抽象方法

public abstract class Animal {
    public abstract void eat();
}

注：子类进行父类中方法的重写

1 如果父类中的方法是普通方法，重写的提示Override

2 如果父类中的方法是抽象方法，重写的提示implement

3.子类和父类的方法

子类的返回值类型，方法名，参数列表必须和父类相同

子类访问权限修饰符大于等于父类的访问权限修饰符

public protected 默认 private

访问权限========》访问的范围

	不同包下的不同类	不同包下的子类	相同包下不同类	当前类
public	可以	可以	可以	可以
protected	不可以	可以	可以	可以
默认default	不可以	不可以	可以	可以
private	不可以	不可以	不可以	可以

4.访问权限修饰符各自应用场景：

1 public 公共的:

​ 一般方法想在任何位置进行使用，使用public

2 protected 受保护的:

​ 同一包下和不同包下的子类中，

​ 例如：以后要用类，不一定是我们写的，别人写好的具有某种功能的类

​ 别人写好的类，类编译进行打包形成jar包，在其他的项目中引入，可以通过子类进行父类中功能的使用===》java项目写完后可以打包

3 默认:

​ 当前包下可以使用========》书写了功能，不希望别人 默认

4 private 私有:

​ 只在当前类中使用的方法和变量

可以修饰类：public，默认

不可以修饰类：private protected

java入门基础—1.4----上一章节: 跳转

java入门基础—1.6----下一章节: 跳转