Java基础之面向对象三大特征

面向对象三大特征

封装

• 封装：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的好处：

• 只能通过规定方法来访问数据
• 隐藏类的实现细节
• 方便修改实现
• 方便加入控制语句

封装的步骤：

• 修改属性的可见性，设置为private
• 创建共有的getter/setter方法，用于属性的读写
• 在getter/setter方法中添加属性控制语句，对属性值的合法性进行判断

this关键字

• 表示对当前对象的引用，也是代表当前类对象的意思
• this关键字可以调用该类中的熟悉和方法
• 在构造函数中也可以调用其他的构造方法，但是必须要放在第一行

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) {
    	if(age > 18){
    		System.out.println("你已成年");
    		this.age = age;
    	}else{
			System.out.println("未成年");
			this.age = age;
		}
   }
}

继承

• 类是对对象的抽象，继承是对某一批类的抽象
• 提高代码的复用性

使用：

• 1、使用继承的时候需要使用extend关键字
• 2、使用继承关系之后，父类中的属性和方法都可以在子类中进行使用(非私有属性和非私有方法)
• 3、java中是单继承关系(如果包含多个父类，同时父类中包含重名方法，无法决定改调用谁)

Super关键字

• super是直接父类的引用
• 在普通方法中，没有顺序限制可以随意通过super调用被子类覆盖的方法或者属性
• 构造函数中，在构造函数中的第一行代码如果没有显式的调用super（）；那么Java默认都会调用super（）；作为父类的初始化函数，所以这里的super（）加不加都可以；
• 在子类的构造方法中调用父类构造函数，必须是第一句
• 在构造方法中super关键字和this关键字不能同时出现
• 父类中私有的属性和方法都不能被调用，包括构造方法
• 子类的构造方法中都会默认使用super关键字调用父类的无参构造方法,因此在定义类的时候，无论自己是否自定义了其他构造方法，最好将无参构造方法写上
• 如果构造方法中显式的指定了super的构造方法，那么无参的构造方法就不会被调用

重写

• 重写的关键字ovveride
• 要求必须是子类继承父类才可以对父类的普通方法进行重写,重写是因为父类方法已经不能满足子类需求
• 重写表示的是子类覆盖父类的方法，所以在调用该方法的时候会优先调用子类方法
• 子类重写父类方法，方法名称，参数列表和返回值类型必须和父类一致
• 子类重写方法类型，访问权限要大于等于父类方法的访问权限

•   父类      public     子类  public
  

•   父类      protected     子类  public protected
  

•   父类      default    子类  public protected  default
  

• 注意:父类的静态方法子类可以进行调用，但是子类不可以重写

public class Person {
    private String name;
    private int age;

    public Person(){}
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("eat...");
    }

}

public class Student extends Person {
    private int studentId;

    public Student(){}
    public Student(int studentId){
        this.studentId = studentId;
    }

}
\\测试子类可以继承父类的方法
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.eat();
    }
}

多态

• 同一个类，对应同一个指令（调用同一个名称的方法），不同的对象给与的反应不同（同一个方法的不同实现）

多态实现的前提

• 必须是继承关系
• 子类方法必须重写父类方法
• 父类引用指向子类对象

多态的两种表现形式

• 父类作为方法的参数
• 父类作为方法的返回值类型

引用类型的转换

• 当父类需要转成子类的时候，要进行强制转换，但是在强制转换之前一定要先判断父类引用指向的子类对象到底是谁，如果无法确定，在运行过程中可以出错
• 当子类需要向父类转换的时候，直接自动转换，不需要进行任何的判断。

public class Pet{
	public void feed(){
		System.out.println("feed..")
	}
}
public class Cat extends Pet{
	@Orrive
	public void feed(){
		System.out.println("feed flash");
	}
}
public class Dog extends Pet{
	@Orrivre
	public void feed(){
		System.out.prinlt("feed beaf");
	}
}
//测试类
public class Test{
	public void feed(Pet pet){
		pet.feed();
	}
	public Pet buyPet(int type){
		if(tyep == 1){
			retutn new Cat(); 	
		}else{
			return new Dog();
		}
	}
	public static void main(String[] args){
		Test test = new Test();
		test.feed(new Dog()); //输出 feed bead;
		Pet pet = test.buyPet(1);//返回cat 对象
		if(pet instanceof cat){
			System.out.println("买的是一只猫");
		}else{
			System.out.println("买的是一只狗");
		}
	}
}