投稿
  1. 极客之音首页
  2. 后端开发
  3. Java

Java新手小白入门篇 Java面向对象（四）

小半 • • Java • 阅读 175

导读：本篇文章讲解 Java新手小白入门篇 Java面向对象（四），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

Java新手小白入门篇 Java面向对象（知识点体系汇总）

  • 面向对象知识链接汇总，知识点体系（思维导图）

Java新手小白入门篇 Java面向对象（一）

  • Java面向对象（第一天）类，对象，方法的重载，练习题

Java新手小白入门篇 Java面向对象（二）

  • Java面向对象（第二天）构造方法，this关键字，内存结构初识，null，NullPointerException，引用类型数组（上），拓展，练习题

Java新手小白入门篇 Java面向对象（三）

  • Java面向对象（第三天）引用类型数组（下），继承，super，向上造型（上），拓展，练习题

Java新手小白入门篇 Java面向对象（四）

  • Java面向对象（第四天）向上造型（下），重写，访问控制修饰符，static关键字，拓展，练习题

Java新手小白入门篇 Java面向对象（五）

  • Java面向对象（第五天）final，static final，abstract关键字（抽象方法，抽象类）

Java新手小白入门篇 Java面向对象（六）

  • Java面向对象（第六天）成员内部类（不经常使用），匿名内部类（经常使用）

Java新手小白入门篇 Java面向对象（七）

  • Java面向对象（第五天）接口，拓展（类与接口的关系，抽象类与接口的区别），练习题

Java新手小白入门篇 Java面向对象（八）

  • Java面向对象（第八天）多态（对象的多态，行为的多态），拓展（面向对象）

Java新手小白入门篇 Java面向对象（九）

  • Java面向对象（第九天）简单的内存结构，面向对象三大特征
  • Java新手小白入门篇系列持续更新中…

文章目录

一、向上造型（下）

1. 超类型的引用指向派生类的对象

public class Test{
	public static void main(String[] args) {
    	//超类型(父类)	引用	指向	  对象(派生类)子类
        Aoo 			o		 = 			new Boo();
    }
}
class Aoo{} //超类
class Boo extends Aoo{} //派生类

2. 能点出来什么，看引用的类型

public class Test{
	public static void main(String[] args) {
    	//超类型(父类)	引用	指向	 对象(派生类)子类
        Aoo 			o		 = 			new Boo();
        o.sayHi(); // Aoo的sayHi方法
        // o.sayHello(); // 报错，引用只能调用Aoo的方法
    }
}
class Aoo{ // 超类
	void sayHi() {
		System.out.println("Aoo的sayHi方法");
	}
}
class Boo extends Aoo{ // 派生类
	void sayHello() {
		System.out.println("Boo的sayHello方法");
	}
}

3. 如果父类的方法被子类所重写，调用的就是子类的方法（看对象的类型）

如不了解 方法的重写，请先参考学习下面重写的知识点

public class Test{
	public static void main(String[] args) {
    	//超类型(父类)	引用	指向	 对象(派生类)子类
        Aoo 			o		 = 			new Boo();
        // 由于sayHi方法被子类重写，实际调用的就是子类的方法
        o.sayHi(); // Boo的重写后的sayHi方法
        // o.sayHello(); // 报错，引用只能调用Aoo的方法
    }
}
class Aoo{ // 超类
	void sayHi() {
		System.out.println("Aoo的sayHi方法");
	}
}
class Boo extends Aoo{ // 派生类
	// 方法的重写
	void sayHi() {
		System.out.println("Boo的重写后的sayHi方法");
	}
	void sayHello() {
		System.out.println("Boo的sayHello方法");
	}
}

二、方法的重写（Override）

1. 定义

重写(覆盖)：父子类中，子类方法与父类方法的名称相同，参数列表也相同我们称之为方法的重写
方法的签名 = 方法名称 + 参数列表
我们又称：父子类中，子类与父类方法的签名相同的方法叫方法的重写
当父类提供的方法不能满足你的业务需求时，需要重写

2. 案例

在这里插入图片描述

三、访问控制修饰符

访问范围 private default（默认的） protected public
本类中 可访问 可访问 可访问 可访问
同包中的其它类 不可访问 可访问 可访问 可访问
不同包中的子类 不可访问 不可访问 可访问 可访问
不同包中的非子类 不可访问 不可访问 不可访问 可访问
  • 类的访问控制权限只能是 public 和 默认的
  • 类中成员的访问权限四种都可以使用

四、static 关键字

static 是Java中的一个关键字，表示静态的意思。表示全局唯一的，一经改变，都进行改变

1. staitc 使用场景

1.1 修饰变量：静态变量

  • 静态变量，又称类变量，由static修饰
  • 属于类，存储的方法区中，只有一份
  • 常常通过类名点的方式来调用
  • 何时用：所有对象所共享的数据（图片、音频、视频）
  • static不能修饰局部变量
public  class Animal { //动物
	public int age = 1;
	public static double weight = 100; //体重
	public void sayHi() {
		this.age = age + 1;
        System.out.println(age);
		this.weight = weight + 5;
        System.out.println(weight);
		System.out.println(age + "/" + weight);
	}
	public static void main(String[] args) {
		Animal a = new Animal();
		a.sayHi();// 2/105.0
		Animal a1 = new Animal();
		a1.sayHi();// 2/110.0
		Animal a2 = new Animal();
		a2.sayHi();// 2/115.0
	}	
}

在这里插入图片描述

1.2 修饰方法：静态方法

  • 由static修饰
  • 属于类，存储的方法区中，只有一份
  • 常常通过类名点的方式来调用
  • 静态方法中没有隐式的this传递，静态方法中不能直接访问实例成员
  • 何时用：方法的操作与对象无关—-方法中不需要访问对象的属性或行为
public class Animal{
    public static String name;//静态变量
	int age;
	public void sayHi() {
        this.name = "动物";
        this.age = 2;
        sayHello(); // 在sayHi这个普通方法中能直接调用sayHello这种实例成员
	}
    public void sayHello() {
	}
	public static void say() {
		Animal.name = " ";
		Animal a = new Animal();
		// age = 18; // 报错,在say这个静态方法中不能直接访问实例成员,需要通过new对象打点的方式访问
		a.age = 5;
		// sayHello(); // 报错,在say这个静态方法中不能直接访问实例成员,需要通过new对象打点的方式访问
        a.sayHello();
	}
}

1.3 修饰代码块：静态代码块

  • 由static修饰
  • 属于类，在类被加载期间自动执行，类只被加载一次，所以静态块也只执行一次
  • 何时用:加载/初始化静态资源(图片、音频、视频等)
public class Animal{
	static {
		System.out.println("静态代码块1");
	}
	static {
		System.out.println("静态代码块2");
	}
	{
		System.out.println("构造代码块");
	}
    Animal(){
    	System.out.println("无参构造");
    }
    
	public static void main(String[] args) {//有输出结果吗?//是什么?	
		// 静态代码块1 -> 静态代码块2 -> 构造代码块 -> 无参构造
        Animal a1 = new Animal();
        // 构造代码块 -> 无参构造
        Animal a2 = new Animal();
	}
}

五、拓展

1. 重载和重写的区别

1.1 概念

  1. 重载（overload）
    • 发生在同一个类中，方法名相同，参数列表不同，方法体不同
    • 与返回值类型无关
    • 编译期绑定
  2. 重写（override）
    • 发生在父子类中，方法名称相同，参数列表相同（方法名称+参数列表=方法的签名）方法体不同
    • 重写遵循两同两小一大
      • 1）两同：方法名相同，参数列表相同（方法的签名）
      • 2）两小：（返回值类型、异常、访问权限）
        • A. 子类方法的返回值小于等于父类方法的返回值
          • a. void/基本类型返回值必须相同
          • b. 引用类型的返回值小于等于父类的返回值
        • B. 子类方法抛出的异常小于或等于超类的方法抛出的异常
      • 3）一大：子类方法的访问权限大于或等于父类方法的
    • 运行期绑定

1.2 案例

重写：

  • 两小

    • 子类方法的返回值小于等于父类方法的返回值

      • void/基本类型返回值必须相同

        • void

          class Aoo{//超类
	void sayHi() {}	
}
class Boo extends Aoo{//派生类
	void sayHi() {}
}

        • 基本类型

          class Aoo{//超类
	int sayHi() {return 1;}	
}
class Boo extends Aoo{//派生类
	int sayH() {return 2;}//是重写
}

          class Aoo{//超类
	int sayHi() {return 1;}	
}
class Boo extends Aoo{//派生类
    double sayHi(){return 4.0;}//不是重写
}

      • 引用类型的返回值小于等于父类的返回值

        • 小于指的是父类方法类型的子类，或者子类的子类，等于是指和父类方法类型相同

          public class Father {}
public class Son extends Father{}

public class Aoo {
    Father getObject() {
        System.out.println("Aoo");
        return new Father();
    }
}
public class Boo extends Aoo{
    Father getObject() {
        System.out.println("Boo");
        return new Father();
    }
}
public class Coo extends Aoo{
    Son getObject() {
        System.out.println("Coo");
        return new Son();
    }
}

public class Demo {
    public static void main(String[] args) {
        Aoo o1 = new Boo();
        o1.getObject(); // Boo
        Aoo o2 = new Coo();
        o2.getObject(); // Coo
    }
}

  • 一大

    • 派生类方法的访问权限大于或等于超类方法的
      在这里插入图片描述

注意：构造方法不能重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是可以被再次声明

2. 变量的划分

变量按照作用域来划分：a.成员变量 b.局部变量

在这里插入图片描述

  1. 成员变量

    • 实例变量
      • 没有static修饰，属于对象的，存储在堆中，有几个对象就有几份（new），通过对象名点来访问
    • 静态变量（类变量）
      • 由static修饰，属于类的，存储在方法区中，只有一份，常常通过类名点来访问
        我们常常说实例变量属于对象，静态变量属于类。
        在这里插入图片描述

  2. 局部变量

    • 形参：方法签名中定义的变量
    • 代码块（语句块）：{ }

六、练习题

1. 练习题

1.1 向上造型，重写

应用知识点：

  • 能点出来什么，看引用的类型
  • 重写的方法被调用时，看对象的类型
1.1.1 第一题
public class Test {
	public static void main(String[] args) {
		Aoo o = new Boo();
		o.sayHi();//输出的是什么?为什么?
		o.sayHello("李四");//输出的是什么?为什么?
	}
}
class Aoo{//超类
	String name;
	Aoo(){}
	Aoo(String name){
		this.name = name;
		System.out.println("超类");
	}
	void sayHi() {
		System.out.println("Aoo的方法");
	}
	void sayHello(String name){
		System.out.println("大家好我叫"+name);
	}
}
class Boo extends Aoo{//派生类
	int age;
	Boo(){}
	Boo(String name,int age){
		super(name);
		this.age = age;
		System.out.println("派生类");
	}
	void sayHi() {
		System.out.println("Boo的方法");
	}
	void sayHello(String name,int age){
		System.out.println("大家好我叫"+name + ",今年"+age+"岁了");
	}
}
1.1.2 第二题
public class Test {
	public static void main(String[] args) {
		Aoo o = new Boo();
		o.sayHi();//输出的是什么?为什么?
		o.sayHello("李四");//输出的是什么?为什么?
	}
}
class Aoo{//超类
	String name;
	Aoo(){}
	Aoo(String name){
		this.name = name;
		System.out.println("超类");
	}
	void sayHi() {
		System.out.println("Aoo的方法");
	}
	void sayHello(String name){
		System.out.println("大家好我叫"+name);
	}
}
class Boo extends Aoo{//派生类
	int age;
	Boo(){}
	Boo(String name,int age){
		super(name);
		this.age = age;
		System.out.println("派生类");
	}
	void sayHi() {
		System.out.println("Boo的方法");
	}
	void sayHello(String name){
		System.out.println("大家好我叫"+name + ",今年"+age+"岁了");
	}
}
1.1.3 第三题
public class Test {
	public static void main(String[] args) {
		Aoo o = new Boo("张三",15);
		o.sayHi();//输出的是什么?为什么?
		o.sayHello("李四");//输出的是什么?为什么?
	}
}
class Aoo{//超类
	String name;
	Aoo(){}
	Aoo(String name){
		this.name = name;
		System.out.println("超类");
	}
	void sayHi() {
		System.out.println("Aoo的方法");
	}
	void sayHello(String name){
		System.out.println("大家好我叫"+name);
	}
}
class Boo extends Aoo{//派生类
	int age;
	Boo(){}
	Boo(String name,int age){
		super(name);
		this.age = age;
		System.out.println("派生类");
	}
	void sayHi() {
		System.out.println("Boo的方法");
	}
	void sayHello(String name){
		System.out.println("大家好我叫"+name + ",今年"+age+"岁了");
	}
}

1.2 静态static

应用知识点：

  • 静态变量属于类
  • 实例变量属于对象
1.2.1 第一题
  • 创建一个 Student 类
    • 变量 money (钱) ，每个学生出门前，兜里揣了100元，（默认值 100 块）
    • 变量 water (饮用水)，教室门前有一桶水，默认值 10000 ml
    • 创建一个方法 buy，方法目的是买水，每个人花 5 元，买500ml 水
    • main 方法中，创建3个学生对象，分别调用买水方法，观察最终每个学生剩多少钱，水剩多少
    • 思考：变量应该是什么变量
    • 分析并画出内存结构图

2. 答案

2.1

  • 未完待续…

2.2

2.2.1

1. 第一种写法

public class Student {

    public double money = 100; // 钱是每个人自己独有的
    public static int water = 10000; // 饮水机里的水是班级里所有学生所共有的

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.buy();
        Student s2 = new Student();
        s2.buy();
        Student s3 = new Student();
        s3.buy();
    }

    void buy() {
        money-=5;
        water-=500;
        System.out.println("money = " + money +" , water = " + water);
    }
}

2. 第二种写法

public class Student {

    public double money = 100;
    public static int water = 10000;

    public static void main(String[] args) {
        Student[] students = new Student[3];
        for (int i = 0; i < students.length; i++) {
            students[i] = new Student();
            students[i].buy();
        }
    }

    void buy() {
        money-=5;
        water-=500;
        System.out.println("money = " + money +" , water = " + water);
    }
}

在这里插入图片描述

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/107639.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！