java中继承、重写、抽象类、抽象方法、多态的学习

最新推荐文章于 2024-04-01 10:05:46 发布

猿字羌

最新推荐文章于 2024-04-01 10:05:46 发布

阅读量722

点赞数

本文链接：https://blog.csdn.net/m0_50551074/article/details/108657157

版权

0.复习：

0.1 静态：

1.静态成员变量：作为数据被所有对象共享属于类的

2.静态成员方法：工具

3.静态代码块：初始化数据

0.2 工具类：

1.Arrays:

1.1 toString：将数组转换成字符串

例如{1,2,3} [1,2,3]

1.2.sort：排序

2.Math:

2.1.ceil ：向上取整

2.2floor: 向下取整

2.3min：最小值

2. 4.max: 最大值

0.3继承：

继承：抽取共性代码复用

使用继承的场景：子类 is a 父类

继承关系的注意事项：

1.父子类中的变量没有重名：父类用自己的，子类没有网上找

2 .父子类有个重名的变量：父类访问自己的，子类优先访问自己的，如果没有则网上找

3. 直接访问：子类子类对象 = 子类（）（等号左边是谁调用的变量就是谁的）

4. 间接访问：方法是谁的方法中访问的变量就是谁的

1.1今日单词：

override重写覆盖

Annotation 注解

abstract 抽象

1.2学习目标：

1.3课堂笔记：

1.继承中重名：

package openBook;

public class Fu {
int number;
public void show() {
System.out.println(number);//省略了this
//System.out.println(this.number);
}

}

package openBook;

public class zi extends Fu {
int number;
}

package openBook;

public class Test {
public static void main(String[]args) {
Fu fu=new Fu();
fu.number=100;//等号左边的类是谁调用的就是谁的变量

    	zi  z=new zi();
    	z.number=200;//等号左边的类是谁调用的就是谁的变量
    	//间接访问   方法是谁的   方法中访问的变量就是谁的
    	fu.show();//show 是父类的      show中访问的number是父类的
    	z.show();//show是父类的        show中访问的number是父类的  (方法是谁的变量就是谁的如果没有变量则找不到子)
    	
    }

}

```

2.三个重名：

局部变量

成员变量

子类变量 this.子类变量

父类变量 super.父类变量

3.切水果案例：

第一版本：

抽象类：水果武器类（main)

切开切割

第二版本：

1.切苹果切开产生白色的特效并加3分

2.切西瓜切开产生红色的特效加5分

3.切菠萝切开产生黄色的特效加10分

第三个版本：

更新：加一个水果产生特效中加彩色特效

芒果

继承：覆盖重写（重写）

重写：存在父子类中方法名相同参数列表相同

重载：存在同类中方法名相同参数列表不相同

                       ```java

package openBook;

public class Test {
public static void main(String[]args) {
Fu fu=new Fu();
fu.number=100;//等号左边的类是谁调用的就是谁的变量

    	//多态：1.父类引用指向子类对象
    	//2.存在重写
    	zi  z=new zi();
    	z.number=200;//等号左边的类是谁调用的就是谁的变量
    	//间接访问   方法是谁的   方法中访问的变量就是谁的
    	fu.show();//show 是父类的      show中访问的number是父类的
    	z.show();//show是父类的        show中访问的number是父类的  (方法是谁的变量就是谁的如果没有变量则找不到子)
    	Apple apple=new Apple();//子类完成功能
    	qieGe(apple);
    	apple.cut();
    	Orange orange=new Orange();
    	qieGe(orange);
    	orange.cut();
    	//覆盖重写的作用：复用父类的功能  方法统一
    	//继承是重写的前提    重写是多态的前提
    	
    }
    //Fruit f=new Apple()
    public static void qieGe(Fruit f) {
    	f.cut();
    	
    }

}

```

4.覆盖重写的注意事项：

                 ```java

package openBook;
/**
*
*

继承中的注意事项
1.重写对返回值的要求子类方法的返回值必须小于等于父类方法的返回值
子类《=父类
String Object
object object
object String 报错
String String
前提父类》子类
Object 万类之祖所有类都继承子Object Object>所有类
Object>String
2.重写方法的权限（访问修饰符）的要求
子类方法的权限必须大于等于父类方法的权限
父类可以访问子类不能访问
public(公开的） >protected(保护的)>default(什么都不写)> private(私有的）（儿子不可以访问）
@author lenovo
*protected(保护）子类可以访问外部可以访问
*public 所有的类都可以
*protected 自己包的类才可以
*private 只有自己类可以

*/
public class Fruit {
String name;
//public object cut(){

 //return new Object();匿名对象
  //保证语法的正确性 
   //}  

 //}
  public void cut() {
	  System.out.println("经过很复杂的切割算法，切开了，美滋滋");
	  
	  if(name=="苹果") {
		  System.out.println("白色特效");
   	      System.out.println("加3分");  
	  }else if(name=="西瓜") {
		  System.out.println("红色特效");
    	   System.out.println("加5分");
	  }
	   //面向对象设计原则：
	        //开闭原则：对拓展开放   对修改关闭
	  //破坏封装性：封装性（将一个功能单独放到一个模块中）
  }

}

```

5.构造函数的继承：

            ```java

package ExtendsDemo3;
/**

1.创建子类对象的时候会先调用父类的构造函数如果父类没有无参的需要super显示调用
2.不能调用多次构造函数父类的构造函数必须放在子类构造函数第一句
3.子类必须调用父类构造函数如果不写就会默认调用无参的
super和this关键子的用法
super的用法：
1.在类方法中调用父类的成员变量
2.在子类方法中调用父类的成员方法覆盖重写
3.在子类方法中可以调用父类的构造函数super();
this的用法：
1.在本类方法中调用本类的成员变量
2.在本类方法中调用本类的成员方法
3.在本类中调用本类的重载构造方法
@author lenovo

*/
public class Zi extends Fu {
public Zi() {
this(10);//调用本类的构造方法
//作用：初始化构造函数的值
//super(10);
this.func();

 // super(); // Constructor call must be the first statement  in a constructor 构造函数调用必须是构造函数中的第一个语句
  //super(10);//显示调用父类构造函数    不写会默认掉用无参的构造函数
  System.out.println("子类的构造函数");
}
private void func() {
  super.name="123";
}
public Zi(int a) {

}

}
```

6.抽象类和抽象方法：

package ExtendsDemo5;

public abstract class Fu {
   public abstract void func();
   //抽象方法只能放在抽象类中
   //抽象类的作用：1.让子类参考
   public abstract void func1();
   public abstract void func2();
   public abstract void func3();
   public void func4() {
	   
   }
}

package ExtendsDemo5;

public class Test {
	public static void main(String[]args) {
	//1抽象方法的语法
	//访问修饰符 abstract  返回值   方法名（参数列表）；
	//2.抽象方法必须在抽象类中
	//访问修饰符 abstract class  类名
	//3.约束抽象类的子类必须重写抽象类中所有的抽象方法
	//抽象类的使用：
	//1.抽线类不能直接创建对象
	//2.想使用父类的对象的化必须使用子类继承抽象类使用（父类引用指向子类对象）
	//3.约束：抽象类的子类必须重写抽象类所有的抽象方法
	//4.抽象类（抽象方法）创建子类才可以使用   而且调用的方法都是子类重写后的方法
	
	//Fu fu=new Fu();//不能实例化类型 Fu(父类是抽象类）
	Fu  fu=new Zi();
	fu.func();//
//	Object obj=1;//万类之祖指向任意东西
//	Object object=new String();
//	Object object2=new Zi();
	}
	//抽象方法必须在抽象类中
	//抽象类可以包含非抽象方法

}

package ExtendsDemo5;
//父类的抽象方法必须重写
//抽象方法约束子类如果子类继承了一个抽象的父类必须重写完其中的抽象方法
//如果不重写继承者的抽象方法则则被继承者就失去了意义
public class Zi extends Fu {

	@Override
	public void func() {
		// TODO 自动生成的方法存根
		System.out.println("你好");
	}
	public void func1() {
		
	}
     
}

7.继承注意事项：

1.单继承：一个类只能有一个父类(一个儿子只能有一个父亲)

错误案例：
     public class Zi extends Fu，ojbect {

	@Override
	public void func() {
		// TODO 自动生成的方法存根
		System.out.println("你好");
	}
	public void func1() {
		
	}
     
}

2.多继承：爷爷爸爸儿子抽象类的子类如果不重写抽象方法子类也是一个抽象类

3.如果子类不去重写父类抽象的方法为了使子类能够正常的运行则子类也要写成抽象类

4.一个类只能有一个直接父类一个父类可以有多个儿子

8.抽象类继承注意事项：

1.抽象类不能创建对象如果创建编译无法通过导致报错只能创建非抽象的子类使用

小贴士：假设抽象类可以创建对象，调用方法的时候调用的就是抽象类的方法，抽象方法没有方法体没意义

2.抽象类可以有构造方法是提供给子类创建对象用的

3.抽象类中不一定包含抽象方法抽象方法必须在抽象类中

4.抽象类的子类必须重写抽象类所有的抽象方法否则编译无法通过导致报错

9.多态和接口：

案例：

老张开车去东北

人车地点（String)

public class Person (){}

public class car(){}

package ExtendsDemo6;

public class person {
      String name;
      public void drive(Car car) {
    	  car.run(name);
    	  
      }
}

package ExtendsDemo6;

public class Car {
     String name;
     public void run(String name) {System.out.println(name+"开着小汽车"+"去东北");
 
     }
     
}

package ExtendsDemo6;

import Demo.hebei1.Person;

public class Test {
   public static void main(String[]args) {
	  person p=new person();
	   p.name="老张";
	   Car car=new Car();
	   car.name="宝马";
	   p.drive(car);
   }
}