继承修饰符

1.继承
继承是面向对象的三大特征之一，可以使子类具有父类的属性和方法，还可以在子类中重新定义。
继承：是通过extends实现的。
格式：class 子类extends 父类（）{}

public class fu {
    public void show(){
        System.out.println("父类方法show被调用");
    }
}
//子类集成父类的格式
public class zi extends fu{
    public void method(){
        System.out.println("子类方法method被调用");
    }
}public class DemoZiFu {
    public static void main(String[] args) {
        //子父类调用
        fu f = new fu();
        f.show();
        //调用子类方法子类没有   会去父类中调用
        zi z = new zi();
        z.method();
        z.show();
    }
}

继承的好处和弊端：
**好处：**提高了代码的复用性（多个类相同的成员可以放大到同一个类中）
提高了代码的维护性（如果代码需要修改，修改父类即可）
**弊端：**削弱了子类的独立性。
应用场景：
考虑类与类之间是否存在is····a的关系。
Java中继承注意事项：
1.Java中只支持单继承不支持多继承
2.支持多层jich。
继承中成员访问的特点：

public class Fu {
    //年龄
    public int age = 40;
}
public class Zi extends Fu {
    //身高
    public int height = 175;
      public  int age=23;
    public void show() {
       // int age=20;
       // 调用年龄的顺序是：  先子类方法中    子类方法外(成员变量)      父类的成员方法
        System.out.println(age);
        System.out.println(height);
        //报错
        //System.out.println(weight);
    }
}
  public class Demo {

            public static void main(String[] args){
                Zi z = new Zi();
                z.show();
            }
}

public class Fu {
    public int age = 40;
}
public class Zi extends Fu {
    public int age = 20;
    public void show() {
        int age = 30;
        System.out.println(age);
        //访问子类变量
        System.out.println(this.age);
        //访问父类变量
        System.out.println(super.age);
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.show();
        System.out.println("-------------------");
        Zi z1 = new Zi();
        z1.show();
    }
}

public class Fu {
    /*public Fu() {
        System.out.println("Fu中无参构造方法被调用");
    }*/
    public Fu() { }
    //两种处理无参构造    要么在zi类中调用有参构造    要么在父类中构造一个
    public Fu(int age) {
        System.out.println("Fu中带参构造方法被调用");
    }
}
public class Zi extends Fu {
    public Zi() {
      // super();//默认回先调用父类的无参构造方法
       // super(20);
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age) {
        //super();
       // super(20);
        System.out.println("Zi中带参构造方法被调用");
    }
public class Demo {
    public static void main(String[] args) {
            Zi z = new Zi();
        final Zi z2 = new Zi(23);

    }
}

public class Fu {
    public void show() {
        System.out.println("Fu中show()方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
    public void show() {
        System.out.println("zi中show()方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
        z.show();
        //调用方法的顺序先到子类中去找    再去父类中找
       // z.test();
        //父子类中都没有的方法回报错
    }
}

public class Phone {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}
public class NewPhone extends Phone {
   /* public void call(String name) {
        System.out.println("开启视频功能");
       // System.out.println("给" + name + "打电话");
        super.call(name);
    }
*/
   @Override
   //为了检查重写方法的正确性
    public void  call(String name){
       System.out.println("开启视频功能");
       //调用父类中的方法
       super.call(name);
   }
   public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Phone p = new Phone();
        p.call("林青霞");
        System.out.println("--------");

        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}
```java
public class Animal {
    private String name;
    private int age;

    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = 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 Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    public void catchMose(){
        System.out.println("猫抓老鼠");
    }
}
public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    public void dogHose(){
        System.out.println("狗看门");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("加菲猫");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.catchMose();
        Cat c2 = new Cat("加菲猫", 5);
        System.out.println(c2.getName()+","+c2.getAge());
        c2.catchMose();
        System.out.println("------------------");
        Dog d = new Dog();
       d.setName("二哈");
        d.setAge(5);
        System.out.println(d.getName()+","+d.getAge());
       d.dogHose();
        Dog d2 = new Dog("二哈",5);
        System.out.println(d2.getName()+","+d2.getAge());
        d2.dogHose();
    }
}

this&super关键字：
this:本类引用。
suoer:代表父类储存空间的标志（可以理解为父类的引用）
注意：子类中所有的构造方法默认都会访问父类中的无参构造，子类会继承父类中的数据还会使用父类中的数据，所以子类初始化之前一定要完成父类数据的初始化，每一个子类构造方法的第一句语句默认都是super（）；

public  final void method() {
        System.out.println("Fu method");
    }
}
public class Zi extends Fu {

   /* @Override
    public void method() {

        System.out.println("Zi method");
    }*/

  public final int age=20;

  public void show(){
     // age=20;
      //fina修饰的变量不能再赋值
      System.out.println(age);
  }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
        z.show();

    }
}

public class Student {
    public int age=10;
public class FinalDemo {
    public static void main(String[] args) {
        //final修饰基本类型变量
		final int age=20;
		//age=100;
		//修饰的基本类型不能被再次使用
        System.out.println(age);
        //final修饰引用类型变量
       final Student s = new Student();
       //final修饰限定的是引用类型的地址值    里面的类容是可以改的
        s.age=25;
        System.out.println(s.age);
    }
}
}

**方法的重写：**子类和父类出现一摸一样的方法声明（方法名一样，参数列表也一样）。
当子类需要父类的功能，而功能主体又有自己独特的类容是，可以重写父类中的方法，这样继承了父类的功能，有定义了子类特有的功能。
@Override注解：用来检测当前的方法，石头是重写的方法，起到校验的作用。
**注意事项：**私有方法不能被重写（父类私有成员是不能被子类继承的）
子类方法访问权限啊不能更低
4. 修饰符4.1 package（了解）
.1、包的概念包就是文件夹，用来管理类文件的
2、包的定义格式package 包名; (多级包用.分开)例如：package com.heima.demo
3、带包编译&带包运行带包编译：javac –d . 类名.java例如：javac -d . com.heima.demo.HelloWorld.j带包运行：java 包名+类名例如：java com.heima.demo.HelloWor
1、包的概念包就是文件夹，用来管理类文件的
2、包的定义格式package 包名; (多级包用.分开)例如：package com.heima.demo
3、带包编译&带包运行带包编译：javac –d . 类名.java例如：javac -d . com.heima.demo.HelloWorld.j带包运行：java 包名+类名例如：java com.heima.demo.HelloWor
Import
导包的格式：
格式：import 包名；
final:
final代表最终的意思，可以修饰成员方法，类
final修饰.类：改类不能被继承（不能有子类，但可以有父类）
final修饰方法：该方法不能被重写
final修饰变量：该方法不能被重写
final修饰变量；表明该变量是一个常量，不能被再次赋值
static

public class Fu {
   private void show1() {
       System.out.println("private");
   }
   void show2() {
       System.out.println("默认");
   }
   protected void show3() {
       System.out.println("protected");
   }
   public void show4() {
       System.out.println("public");
   }
   public static void main(String[] args) {
       //创建Fu的对象，测试看有哪些方法可以使用
       Fu f = new Fu();
       f.show1();
       f.show2();
       f.show3();
       f.show4();
   }
}
public class Zi extends Fu {
   public static void main(String[] args) {
       //创建Zi的对象，测试看有哪些方法可以使用
       Zi z = new Zi();
       z.show2();
       z.show3();
       z.show4();
   }
}
public class Demo {

   public static void main(String[] args) {
       //创建Fu的对象，测试看有哪些方法可以使用
       Fu f = new Fu();
       f.show4();
       f.show3();
       f.show2();
   }
}

继承 修饰符

猜你喜欢