黑马全套Java教程（四）

文章目录

• 14 继承
• • 14.1 概述
  • 14.2 继承中变量的访问特点
  • 14.3 super关键字
  • 14.4 继承中构造方法的访问特点
  • 14.5 继承中成员方法的访问特点
  • 14.6 方法重写
  • 14.7 Java中继承注意事项
• 15 包
• • 15.1 包的定义
  • 15.2 import导包
• 16 修饰符
• • 16.1 权限修饰符
  • 16.2 状态修饰符
  • • 1. final
    • 2. static
• 17 多态
• • 17.1 多态概述
  • 17.2 多态访问特点
  • 17.3 多态的好处和弊端
  • 17.4 多态中的转型

黑马全套Java教程（一）
黑马全套Java教程（二）
黑马全套Java教程（三）

本博客从黑马第150个视频开始，视频链接

14 继承

14.1 概述

继承概述：继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义、追加属性和方法。

继承格式
格式：public class 子类 extends 父类{}
范例：public class Zi extends Fu{}
Fu：是父类，也被称为基类、超类
Zi：是子类，也被称为派生类

继承中子类的特点

• 子类可以有父类的内容
• 子类还可以有自己特有的内容

继承的好处

• 提高了代码的复用性：多个类相同的成员可以放到同一个类中
• 提高了代码的维护性：如果方法的代码需要修改，修改一处即可

继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时，子类也不得不跟着变化，削弱了子类的独立性

什么时候用继承？
比如猫、狗，都是动物，是动物的一种，所以可以继承动物类

代码实现如下：
父类：Fu.java

public class Fu {public void show() {System.out.println("show方法被调用");}
}

子类：Zi.java

public class Zi extends Fu{   //extends关键字继承父类public void method() {System.out.println("method方法被调用");}
}

测试类：Demo.java

public class Demo {public static void main(String[] args) {//创建对象，调用方法Fu f = new Fu();f.show();System.out.println("-----------------");Zi z = new Zi();z.method();z.show();}
}

14.2 继承中变量的访问特点

就近原则
在子类方法中访问一个变量，按下面顺序寻找：

• 子类局部范围找
• 子类成员范围找
• 父类成员范围找
• 报错

代码实现：
Fu.java

public class Fu {public int age = 40;
}

Zi.java

public class Zi extends Fu {//身高public int height = 175;public int age = 20;public void show(){int age = 30;System.out.println("age:" + age);System.out.println("height:" + height);}
}

Demo.java

public class Demo {public static void main(String[] args) {//创建对象，调用方法Zi z = new Zi();z.show();}
}

14.3 super关键字

super关键字的用法和this关键字的用法相似

• this：代表本类对象引用
• super：代表分类存储空间的标识（可以理解为父类对象引用）
  

代码实现：
Fu.java

public class Fu {public int age = 40;
}

Zi.java

public class Zi extends Fu {//身高public int age = 20;public void show(){int age = 30;System.out.println("局部变量age:" + age);//我要访问本类的成员变量ageSystem.out.println("子类的成员变量：" + this.age);//我要访问父类的成员变量ageSystem.out.println("子类的成员变量" + super.age);}
}

Demo.java

public class Demo {public static void main(String[] args) {//创建对象，调用方法Zi z = new Zi();z.show();}
}

14.4 继承中构造方法的访问特点

• 子类中所有的构造方法默认都会访问父类中无参的构造方法

为什么呢？

• 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
• 每一个子类构造方法的第一条语句默认都是：super()

代码实现：
Fu.java

package Demo4;public class Fu {public Fu(){System.out.println("Fu中无参构造方法被调用");}public Fu(int age){System.out.println("Fu中带参构造方法被调用");}
}

Zi.java

package Demo4;public class Zi extends Fu {public Zi(){System.out.println("Zi中无参构造方法被调用");}public Zi(int age){System.out.println("Zi中带参构造方法被调用");}
}

Demo.java

package Demo4;public class Demo {public static void main(String[] args) {//创建对象Zi z = new Zi();System.out.println("--------------");Zi z2 = new Zi(20);}
}

上面子类也可以这样写：都加个super()

package Demo4;public class Zi extends Fu {public Zi(){super();System.out.println("Zi中无参构造方法被调用");}public Zi(int age){super();System.out.println("Zi中带参构造方法被调用");}
}

若需要调用父类带参构造方法，子类可以做如下修改：

package Demo4;public class Zi extends Fu {public Zi(){super(20);   //写与不写效果一样System.out.println("Zi中无参构造方法被调用");}public Zi(int age){super(20);System.out.println("Zi中带参构造方法被调用");}
}

如果父类中只有带参构造方法，没有无参构造方法，我们又想调用父类无参构造方法，我们可以手动写一个父类无参构造方法

总结如下：

14.5 继承中成员方法的访问特点

通过子类对象访问一个方法，顺序如下：

• 子类成员范围找
• 父类成员范围找
• 如果都没用就报错（不考虑父亲的父亲…）

代码实现：
Fu.java

package Demo5;public class Fu {public void show() {System.out.println("Fu中的show方法被调用");}
}

Zi.java

package Demo5;public class Zi extends Fu {public void method() {System.out.println("Zi中的method方法被调用");}public void show() {super.show();System.out.println("Zi中的show方法被调用");} //就近原则
}

Demo.java

package Demo5;public class Demo {public static void main(String[] args) {//创建对象，调用方法Zi z = new Zi();z.method();z.show();}
}

14.6 方法重写

方法重写概述
子类中出现了和父类中一模一样的方法声明

方法重写的应用
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样沿袭的父类的功能，又定义了子类特有的内容

Phone.java

package Demo6;
/*手机类*/
public class Phone {public void call(String name) {System.out.println("给" + name + "打电话");}
}

NewPhone.java

package Demo6;
/*新手机*/
public class NewPhone extends Phone{@Override  //重写注解  ，可以帮助检查重写的方法正确性public void call(String name){  //方法重写System.out.println("开启视频功能");
//        System.out.println("给" + name + "打电话");super.call(name);  //实现上面那句功能}
}

PhoneDemo.java

package Demo6;public class PhoneDemo {public static void main(String[] args) {//创建对象，调用方法Phone p = new Phone();p.call("林青霞");System.out.println("----------");NewPhone np = new NewPhone();np.call("林青霞");}
}

方法重写的注意事项

1. 私有方法不能被重写（父类中私有成员子类是不能继承的）
2. 子类方法访问权限不能更低**（public>默认>私有）**
   
   
   
   

14.7 Java中继承注意事项

代码实现如下：
Father.java

package Demo8;public class Father extends Granddad{public void smoke(){System.out.println("爸爸爱抽烟");}
}

Granddad.java

package Demo8;public class Granddad {public void drink(){System.out.println("爷爷爱喝酒");}
}

Mother.java

package Demo8;public class Mother {public void dance(){System.out.println("妈妈爱跳舞");}
}

Son.java

package Demo8;//Java不支持集继承多个类
//但是Java能多层继承，爸爸继承爷爷，儿子继承爸爸
public class Son extends Father{
}

案例：老师和学生

Person.java

package Demo10;public class Person {private String name;private int age;public Person() {}public Person(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;}
}

Teacher.java

package Demo10;public class Teacher extends Person{public Teacher(){}public Teacher(String name, int age){   //带参构造方法
//        this.name = name;
//        this.age = age;super(name, age); //实现传递}public void teach(){System.out.println("用爱成就每一位学员");}
}

Student.java

package Demo10;public class Student extends Person{public void study(){System.out.println("好好学习，天天向上！");}
}

Demo.java

package Demo10;
/*测试类*/
public class Demo {public static void main(String[] args) {//创建老师类对象，并测试Teacher t1 = new Teacher();t1.setName("林青霞");t1.setAge(30);System.out.println(t1.getName() + "," + t1.getAge());t1.teach();Teacher t2 = new Teacher("风清扬", 33);   //调用带参构造System.out.println(t2.getName() + "," + t2.getAge());t2.teach();}
}

案例2：猫和狗

Animal.java

package Demo11;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;}
}

Cat.java

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

Dog.java

package Demo11;public class Dog extends Animal{public Dog() {}public Dog(String name, int age) {super(name, age);}public void lookDoor(){System.out.println("狗看门");}
}

Demo.java

package Demo11;/*测试类*/
public class Demo {public static void main(String[] args) {//创建猫类对象，并测试Cat c1 = new Cat();c1.setName("加菲猫");c1.setAge(5);System.out.println(c1.getName() + "," + c1.getAge());c1.catchMouse();Cat c2 = new Cat("橘猫", 6);System.out.println(c2.getName() + "," + c2.getAge());c2.catchMouse();}
}

15 包

15.1 包的定义

包的概述
其实就是文件夹
作用：对类进行分类管理

包的定义格式
格式：package 包名;，（多级包用.分开）
范例：package aaa.bbb

带包的Java类编译和执行

记事本演示如下：

编译演示如下
这里需要手动建立Demo01包，然后把生成的class文件放入包中
注意：运行也要带包，要不然会报错

编译演示二：自动建包
这里不需要手动建包，-d运行可以自动建立

15.2 import导包

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化带包的操作，Java就提供了导包的功能

导包的格式
格式：import 包名;
范例：import bao1.bao2.lei1

例如：我要在同一个模块下的Demo2包的Demo.Java中使用Demo1包下的Teacher.Java，就需要导包
代码如下：

16 修饰符

修饰符的分类

• 权限修饰符
• 状态修饰符

16.1 权限修饰符

我们在Demo1中创建三个类：
Fu.Java

package Demo1;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();}
}

Zi.Java

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

Demo.Java

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

之后我们在Demo2中创建两个类：

16.2 状态修饰符

• final（最终态）
• static（静态）

1. final

final关键字是最终的意思，可以修饰成员方法、成员变量、类

final修饰的特点：

1. 修饰方法：表明该方法是最终方法，不能被重写
2. 修饰变量：表明该变量是常量，不能再次被赋值
3. 修饰类：表明该类是最终类，不能被继承

代码实现：
1.修饰方法：被final修饰的方法叫最终方法，不可被重写

2.修饰变量：被final修饰的变量不能再次修改

3.修饰类：被final修饰的类不可被继承

final修饰局部变量

• 变量是基本类型：final修饰基本类型的数据值不能发生改变
• 变量是引用类型：final修饰引用类型的地址值不能发生改变，但是地址里面的内容是可以改变的

package Demo2;
/*测试类*/
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();s.age = 100;System.out.println(s.age);//s = new Student();   //报错}
}

2. static

static关键字是静态的意思，可以修饰成员方法、成员变量

特点：

• 被类的所有对象共享
• 可以通过类名调用

static.Java

package Demo3;public class Student {public String name;public int age;//public String university;public static String university;   //所有成员共享public void show(){System.out.println(name + "," + age + "," + university);}
}

staticDemo.Java

package Demo3;public class StaticDemo {public static void main(String[] args) {Student.university = "南昌";Student s1 = new Student();s1.name = "林青霞";s1.age = 30;//s1.university = "南昌";   //不建议这样s1.show();Student s2 = new Student();s2.name = "风清扬";s2.age = 33;//s2.university = "南昌";s2.show();}
}

静态访问特点

package Demo4;
/*static访问特点*/public class Student {//非静态成员变量private String name = "林青霞";//静态成员变量private static String university = "南昌";//非静态成员方法public void show1(){}//静态成员方法public static void show3(){}//非静态成员方法public void show2(){System.out.println(name);System.out.println(university);show1();show3();}//静态成员方法public static void show4(){  //静态成员方法只能访问静态成员变量和静态成员方法//System.out.println(name);   //报错System.out.println(university);//show1();                    //报错show3();}
}

17 多态

17.1 多态概述

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

举例：猫
我们可以说猫是猫：猫 cat = new 猫();
我们也可以说猫是动物：动物 animal = new 猫();
这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态的前提和体现

• 有继承/实现关系
• 有方法重写
• 有父类引用指向子类对象

Animal.java

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

Cat.java

package Demo1;public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

AnimalDemo.java

package Demo1;
/*多态：同一个对象，在不同时刻表现出来的不同形态举例：猫我们可以说猫是猫：     猫 cat = new 猫();我们也可以说猫是动物：  动物 animal = new 猫();多态的前提和体现有继承/实现关系有方法重写有父类引用指向子类对象*/public class AnimalDemo {public static void main(String[] args) {//有父类引用指向子类对象Animal a = new Cat();a.eat();}
}

17.2 多态访问特点

• 成员变量：编译看左边，执行看左边
• 成员方法：编译看左边，执行看右边

为什么成员变量和成员方法的访问不一样呢？

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

Animal.java

package Demo2;public class Animal {public int age = 40;public void eat(){System.out.println("动物吃东西");}
}

Cat.java

package Demo2;public class Cat extends Animal {public int age = 20;public int weight = 10;@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame(){System.out.println("猫捉迷藏");}
}

AnimalDemo.java

package Demo2;public class AnimalDemo {public static void main(String[] args) {//有父类引用指向子类对象Animal a = new Cat();System.out.println(a.age);  //40，父类中的//System.out.println(a.weight);  //报错a.eat();  //子类中的//a.playGame();   //报错}
}

17.3 多态的好处和弊端

多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
多态的弊端：不能使用子类的特有功能

Animal.java

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

Cat.java

package Demo3;public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

Dog.java

package Demo3;public class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}public void lookDoor(){System.out.println("狗看门");}
}

Pig.java

package Demo3;public class Pig extends Animal{@Overridepublic void eat() {System.out.println("猪吃白菜");}
}

AnimalOperator.java

package Demo3;
/*动物操作类*/
public class AnimalOperator {
//    public void useAnimal(Cat c){ //Cat c = new Cat();
//        c.eat();
//    }
//    public void useAnimal(Dog d){
//        d.eat();
//    }public void useAnimal(Animal a){//相当于//Animal a = new Cat();//Animal a = new Dog();a.eat();//a.loolDoor();   //不能访问具体子类所特有的功能}
}

AnimalDemo.java

package Demo3;
/*测试类*/
public class AnimalDemo {public static void main(String[] args) {//创建动物操作类的对象，调用方法AnimalOperator ao = new AnimalOperator();Cat c = new Cat();ao.useAnimal(c);System.out.println("--------------");Dog d = new Dog();ao.useAnimal(d);Pig p = new Pig();ao.useAnimal(p);}
}

17.4 多态中的转型

• 向上转型：从子到父，父类引用指向子类对象
• 向下转型：从父到子，父类引用转为子类对象

Animal.java

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

Cat.java

package Demo4;public class Cat extends Animal{@Overridepublic void eat(){System.out.println("猫吃鱼");}public void playGame(){System.out.println("猫捉迷藏");}
}

AnimalDemo.java

package Demo4;
/*向上转型从子到父父类引用指向子类对象向下转型从父到子父类引用转为子类对象*/
public class AnimalDemo {public static void main(String[] args) {//多态Animal a = new Cat();  //向上转型a.eat();//a.playGame();   //报错System.out.println("-------------------");//创建Cat类的对象
//        Cat c = new Cat();
//        c.eat();
//        c.playGame();
//        System.out.println("------------");//向下转型Cat c = (Cat)a;c.eat();c.playGame();}
}

案例：猫和狗

Animal.java

package Demo5;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 void eat(){System.out.println("动物吃东西");}
}

Cat.java

package Demo5;public class Cat extends Animal{public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

Dog.java

package Demo5;public class Dog extends Animal{public Dog() {}public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("狗吃骨头");}
}

AnimalDemo.java

package Demo5;
/*测试类*/
public class AnimalDemo {public static void main(String[] args) {//创建猫类进行测试Animal a = new Cat();a.setName("加菲猫");a.setAge(5);System.out.println(a.getName() + "," + a.getAge());a.eat();a = new Cat("橘猫", 5);System.out.println(a.getName() + "," + a.getAge());a.eat();}
}

本博客到视频d174截止!

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！