对Java面向对象编程的知识点（封装、继承，多态）进行总结

最新推荐文章于 2023-05-22 14:42:02 发布

weixin_42593363

最新推荐文章于 2023-05-22 14:42:02 发布

阅读量717

点赞数

本文链接：https://blog.csdn.net/weixin_42593363/article/details/81166115

版权

一封装

1.面向对象的高级：优化程序设计
封装：
类中如何定义成员变量？
   private int num;
概念
   语法
   3步骤
继承：减少冗余代码
继承:一个类（子类）继承另一个类（父类）
概念
   语法
   extends
   重载？？
final(修饰符)
static（main方法，static）
多态：
一种事物的多种表现形式
概念
   语法
   Father fa=new Son();//实例化
       //Son son=new Son();
   接口：代表能力，一种约定。
   implement interface
Java语言就是使用面向对象开发出来的。
Date 时间
   Calendar 日历
   Math
   包装类 Integer Double Short Float Boolean
   集合（不同结构不同使用）
   异常（Exception）
   文件！IO流
   内存(基本数据类型的变量中，引用数据类型的变量中应用)
   int num=9;
   String str="admin";
   Student stu=new Student();
   int[] nums={};
   Student[] stus=new Student[10];
写入
   内存---------》文件
   《--------
       读取
3.封装
隐藏成员变量
1.隐藏成员变量
将成员变量前加入修饰符private
   结果：其他类在创建狗的对象的时候，在调用成员变量时显示错误。
   The field Dog.name is not visible
2.创建公有的getter/setter方法
   在此类中创建公有方法
   创建成员变量的赋值方法
       public void setName(String name1){
       }
注意：1.方法名称必须是set+成员变量第一个单词首字母大写的成员变量名称
       2.方法的参数必须是成员变量的类型
成员变量的取值方法
       public String getName(){
           return name;//返回成员变量值
       }
注意：1.方法名称必须是get+成员变量第一个单词首字母大写的成员变量名称
       2.方法的返回值必须是成员变量的类型（返回的是成员变量里面的值）
3.在setter/getter方法中给加入属性控制
4.setter方法的参数名称和成员变量名称保持一致。（防止乱起名字）
   this.name=name;
5.在本类中调用自己的成员变量和成员方法的时候，使用this
this代表当前对象
6.特殊方法的第一种。

构造方法：实例化--》创建对象+对象赋成员变量值

Constructor


语法
   publlic 类名(){

   }
   public Dog(){

   }


1,创建类的时候都会有一个隐藏的无参构造方法。
2,创建对象的时候就会调相应的构造方法。
3,构造方法由于方法名称相同，因此构造方法的参数定义时注意，
   不要两个构造方法的传递参数一致（顺序类型个数）。
4,当你在类中定义有参构造方法，隐藏的无参构造方法失效。
   因此必须在类中显示定义构造方法

   实例化两种方法

   第一种
   Dog dog=new Dog();

   dog.setName("");
       dog.setHealth();
       dog.setStrain("");
第二种
   Dog dog=new Dog("",,"");

二继承
static{

}

1.继承初始化顺序？
2.方法的重载和重写？
3.abstract final关键字

1.继承概念

super 代表父类
this 代表本类
子类 extends 父类
2.继承关系初始化顺序。
父类属性--》父类的构造方法--》子类属性--》子类的构造方法
先父后子
先属后构

3.方法的重载和重写？overloading和override区别
重载 overloading
规则：同一个类中
   方法名称相同
       参数列表必须不相同(类型个数顺序)
       返回值类型和访问修饰符无关
构造方法重载
   public Student(){}
   public Student(String name){}
   public Student(String sex){}//错误
   public Student(String name,int age){}
   //方法名称具体意义
重写 override
规则：在继承关系中体现
   方法名字相同
       参数列表必须相同
       返回值的类型相同或者是其子类
       访问修饰符不能严于父类（父类是protected 子类是protected public ）
方法重写：相对于继承而言，子类中对父类已经存在的方法进行区别修改。

4.abstract 抽象类

1.修饰class后变为抽象类，限制实例化
   2.Pet类定义方法没有意义
   因此我们可以在Pet类中定义方法为抽象方法，
   抽象方法没有方法体。

1）修饰类限制实例化
2）修饰方法限制方法的实现，没有方法体

   抽象方法的实现步骤
   1.在父类的方法前添加abstract，去除方法体
   2.在子类中重写此抽象方法

   为什么使用抽象方法？
   1.父类只是知道子类应该有哪些方法，但是无法准确完成方法具体实现
   2.避免子类设计的随意性
   总结
1.父类中编写抽象方法，子类必须重写
2.抽象类中可以有普通方法，也可以有抽象方法
3.抽象方法必须在抽象类中

5.final关键字

修饰类
此类就不能被继承
修饰方法
此方法不能被重写
   注意：final和abstract是两个相反的单词，绝对不能同时修饰
修饰变量
常量：所有单词字母全部大写
   USER_NAME AMDIN_NAME
       final String ORACLE_PASSWORD="123456";
   int num=9;
   num：变量
   9:常量

   永远都不会被改变的
   成员变量
   修饰成员变量必须声明的时候就赋值或者在构造方法中初始化
6.Object 上帝类祖宗类

Object类是所有类的父类。
如果一个类没有使用extends关键字标识继承另一个类，那么这个类默认继承Object

因此自定义的类和底层开发人员的类

String str="";
str.equals("");//equals标明并不是在Object类，是String类。因为String子类重写了Object父类里的方法

Object类中的主要方法。

   1.equals ：比较对象的引用是否指向同一块内存地址。（引用：指向一块内存地址）
作业：想使用equals判断两个对象的属性是否相同。--》重写equlas
   2.toString()
   StringBuffer--》toString()--->StringBuffer转换为String类型

       返回的是哈希码值(对象地址字符串)。（Hash）

我们直接使用System.out.println(dog);输出一个对象
结果就是对象的地址字符串也叫哈希码值（com.sisp.oop4.object.Dog@659e0bfd）

哈希码值：通过哈希算法(Hash)生成的一个字符串，用来区分我们的对象地址码。

刘** 210123...

变量名哈希码值

子类可以重写toString

3.getClass() 可以得到此对象的类型
System.out.println(dog.getClass());
//class com.sisp.oop4.object.Dog

三多态

1.面向对象的第三大特性
多态

生活中的多态
同一种事物，由于条件不同，则产生不同的结果
   事物的多种表现形态
程序中多态
   同一个引用类型，使用不同的实例，执行不同的操作

       父类的引用子类的实现
       //使用多态进行实例化
       Pet pet=new Dog();
       Pet pet=new Penguin();
       Pet pet=new Cat();
2.多态发生在继承关系中
3.多态实现的前提

   1.类与类之间存在继承关系
   2.类与接口之间存在实现关系（之后章节）
4.多态实现的步骤

1.编写父类
   2.编写子类，一定要有子类重写父类的方法
   3.使用时，就可以使用父类的引用类型，子类的实例！！
   //使用多态进行实例化
       Pet pet=new Dog();
       Pet pet=new Penguin();
       Pet pet=new Cat();
5.多态实现的方式
1.Pet pet=new Dog();
2.使用父类作为方法的形参实现多态，
调用具体方法传入实参作为子类的实例
3.使用父类作为方法的返回值实现多态，
定义方法的返回值为父类，调用方法的返回值为子类的实例
6.优点：程序的可扩展性
缺点：使用多态进行实例化，实例化的对象只能调用子类重写父类的方法，
子类特有的方法我们无法调用

       如何解决弊端？

       1.向上类型（自动类型转换）

           Pet pet=new Dog();

       好处：隐藏子类型，提供代码的可扩展型
           弊端：只能调用子类重写父类的方法，子类特有的方法我们无法调用
2.向下类型（强制类型转换）
       int b=(int)9.8;

Pet pet=new Dog();
           pet.eat();

           Dog dog=(Dog)pet;

dog.catchFlyDisc();

好处：能调用子类特有方法
           弊端：向下类型有风险
容易发生异常
                   java.lang.ClassCastException（类型转换异常）

           使用前进行判断，判断一个对象是否匹配另一个对象类型

               对象 instanceof 类型（类名）

建立父类

package com.sisp.poly1;

public abstract class Pet {
	
	protected String name;
	protected int health;
	protected int love;
	
	public void setName(String name) {
		this.name = name;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public String getName() {
		return name;
	}
	public void setLove(int love) {
		this.love = love;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}	
	public Pet() {
	}
	public Pet(String name, int health, int love) {
		this.name = name;
		this.health = health;
		this.love = love;
	}
	//The abstract method eat in type Pet
    //can only be defined by an abstract class
	/**
	 * 吃食
	 */
	public abstract void eat();
}

建立企鹅类

package com.sisp.poly1;

public class Penguin extends Pet{

	private String sex;
	
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Penguin() {
	}
	public Penguin(String sex) {
		this.sex = sex;
	}	
	public Penguin(String name,int health,int love,String sex) {
		super(name,health,love);
		this.sex = sex;
	}
	public void show(){
		System.out.println("自我介绍:我的名字:"+
		                   super.name+",健康值:"+
				           super.health+",亲密度"+
				           super.love+",性别 :"+
				           this.sex);
	}
	@Override
	public void eat() {
		 if(super.health>200){
	    	   System.out.println("吃饱啦");
	       }else{
	    	   System.out.println("企鹅正在吃食");
	    	   super.health=super.health+50;
	       }	
		
	}

建立猫类

package com.sisp.poly1;

public class Cat extends Pet{

	String color;

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public Cat() {
	
	}
	public Cat(String name,int health,int love,String color){
		super(name,health,love);
		this.color=color;
	}
	public void show(){
		System.out.println("自我介绍:我的名字:"+
		                   super.name+",健康值:"+
				           super.health+",亲密度"+
				           super.love+",颜色:"+
				           this.color);
	}

	@Override
	public void eat() {
		
		if(super.health>200){
	    	   System.out.println("吃饱啦");
	       }else{
	    	   System.out.println("猫正在吃食");
	    	   super.health=super.health+10;
	       }	
		
	}
	
}

建立饲养员类

package com.sisp.poly1;

public class Master {
	
	private String name;
	private int money;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public Master() {
	}
	public Master(String name, int money) {
		this.name = name;
		this.money = money;
	}
	public void feed(Pet pet){//Pet pet=new Dog()
		pet.eat();
	}
	/*public void feed(Penguin pg){
		pg.eat();
	}
	public void feed(Cat cat){
		cat.eat();
	}*/

}

建立执行类

package com.sisp.poly1;

public class Demo {

	public static void main(String[] args) {
		
		 Master master=new Master("刘小姐",100);
		
		 Cat cat=new Cat("欧欧", 100, 80, "卡布拉多");
		 
		  master.feed(cat);
		
		  cat.show();

		 Penguin pg=new Penguin("贝贝",80,80,"男");
		   master.feed(pg);
		   pg.show(); 
		
	}

}

weixin_42593363

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
对Java面向对象编程的知识点（封装、继承，多态）进行总结

一封装1.面向对象的高级：优化程序设计封装：类中如何定义成员变量？ private int num; 概念语法 3步骤继承：减少冗余代码继承:一个类（子类）继承另一个类（父类）概念语法 extends 重载？？ final(修饰符) ...
复制链接

扫一扫