JAVASE-三大特性之封装，继承和多态

女爷i 2022-11-11 05:53 152阅读 0赞

# 三大特性-封装，继承和多态 #

## 一.封装 ##

### **1.封装：** ###

> 将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
> 
> (尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。)
> 
> get/set方法是外界获取和访问对象私有属性的唯一通道，

### ***2. 注意！！！*** ###

>  *  不管是**this**还是**super**都必须是第一行,所以在构造方法中,只能调用其中之一
>  *  super可以调用父类的有参或无惨构造方法 super(); super(" "," ");
>  *  没有显式的写super(),就会默认调用父类的无参构造方法==>super()
>  *  写构造方法时，最好写上无参构造方法。避免报错

### 3.代码演示： ###

案例一：

public class Test{
    	public static void main(String[] args) {
    
    		Student s1 = new Student();
    		
    		s1.name = "tom";
    		//s1.age = 20;          //安全，无法直接访问到私有属性
    		s1.setAge(20);          //调用方法完成赋值操作
    		
    		s1.sex = "male";
    		s1.score = 99.0;
    		
    		System.out.println( s1.getAge() );      //调用方法完成取值操作
    		
    	}
    }
    
    class Student{
    	String name;           //属性也称为字段
    	private int age;       //私有属性，本类可见，其他位置不可见
    	String sex;
    	double score;
    	
    	public Student() {}
    	
    	/**
    	 * 为age属性赋值的方法
    	 */
    	public void setAge(int age) {        //20000
    		if(age >= 0 && age <= 153) {     //合法区间
    			this.age = age;
    		}else {
    			this.age = 18;//如果录入的数据不合法，默认使用18代表用户的年龄
    		}
    	}
    	
    	/**
    	 * 为age属性取值的方法
    	 */
    	public int getAge() {
    		return this.age;
    	}
    }

案例二：

public class Test{
    
    	public static void main(String[] args) {
    
    		Teacher t1 = new Teacher();
    		
    		t1.setName("jack");
    		t1.setAge(20);
    		t1.setSex("male");
    		t1.setSalary(2000.0);
    		
    		System.out.println(t1.getName() +"\t"+ t1.getAge() +"\t"+ t1.getSex() +"\t"+ t1.getSalary());
    		
    	}
    }
    
    class Teacher{
    	private String name;
    	private int age;
    	private String sex;
    	private double salary;
    	
    	public Teacher() {}
    	
    	public void setName(String name) {
    		this.name = name;
    	}	
    	public String getName() {
    		return this.name;
    	}	
    	public void setAge(int age) {
    		this.age = age;
    	}	
    	public int getAge() {
    		return this.age;
    	}	
    	public void setSex(String sex) {
    		this.sex = sex;
    	}	
    	public String getSex() {
    		return this.sex;
    	}	
    	public void setSalary(double salary) {
    		this.salary = salary;
    	}	
    	public double getSalary() {
    		return this.salary;
    	}	
    }

## 二.继承 ##

### 1.继承 ###

>  *  类与类之间特征和行为的赠与或获得。
>  *  两个类之间的继承关系，必须满足"is a" 的关系。

### 2.语法： ###

> **class 子类extends父类\{\}**

### 3.应用： ###

> **有继承关系后，子类可以使用父类的属性和方法，也可以定义自己独有的属性和方法**

### 4.好处： ###

> **既可以提高代码的复用性，又可以调高代码的可扩张性。**

--------------------

> java为单继承，一个类只有一个父类，但可以多级继承

### 5.访问修饰符 ###

private→default→protected→public      从严到宽

private String a = "A";   //私有的 只有本类可用
    
    String b = "B";           //默认的 default 同包可用
    
    protected String c = "C"; //受保护的
    
    public String d = "D";    //公开的

** 案例：**

public class Animal {
    	private String name;               //私有
    	int age;                           //默认访问修饰符
    	protected String type;             //受保护的
    	public String sex;                 //公开的
    	
    	public void test() {
            //都可以进行访问
    		System.out.println(this.name);
    		System.out.println(this.age);
    		System.out.println(this.type);
    		System.out.println(this.sex);
    	}	
    }
    
    public class Dog extends Animal {
    
    	public void sayHi() {
    		//System.out.println(name);//私有属性不可访问
    		//同包默认访问修饰符可用
    		//不同包子类无法访问
    		System.out.println(age);
    		//同包子类可用
    		//不同包子类可用
    		System.out.println(type);  
    		System.out.println(sex);
    	}	
    }
    
    public class Test {
    	public static void main(String[] args) {
    		Animal a = new Animal();
                    a.test();
            Dog g=new Dog();
                g.sayHi();               
    	}
    	
    }

## ##

### 6.重写与重载的区别 ###

**6.1方法重写（在继承的基础上）**

> 原则：
> 
>  *    方法名相同，参数列表与父类相同
>  *    返回值类型必须与父类或其子类相同
>  *    访问修饰符可与父类相同或者比父类更宽

**6.2方法重载：**

>  *   方法名相同
>  *  参数列表不同（个数，位置，类型）
>  *  与返回值类型和访问修饰符无关

### 7.super关键字 ###

**7.1访问方法**

> super关键字可在子类中访问父类的方法。
> 
>  *  super调方法: super.方法,表示调父类的方法

案例：

public class A {                     //A类（父类）
    
    	public A() {
    		System.out.println("this is A");
    	}	
    }
    
    public class B extends A{            //B类继承A类
    
    	public B() {
    		System.out.println("this is B");
    	}
    }
    
    public class C extends B {            //C类继承B类
    
    	public C() {
    		super();                      //super会最先调用父类的构造方法
    		System.out.println("this is C");
    	}
    }
    
    public class Test {
    
    	public static void main(String[] args) {
    		new C();
    	}
    
    }

**7.2访问属性**

> super调属性: super.属性,表示调父类的属性

**7.3调用父类的构造器**

>  *  super()：表示调用父类无参构造方法。
>  *  super(实参)：表示调用父类有参构造方法。

**案例：**

public class Person {
    	String name="person";
    	
    	public void sayHi() {
    		System.out.println("我们已经sayHi了100遍");
    	}	
    }
    
    public class Student extends Person {
    	
    	String name="student";	
    	public void test() {
    		String name = "test";
    		System.out.println(super.name);
    		System.out.println(this.name);
    		System.out.println(name);
    		super.sayHi();
    	}
    	
    	public void sayHi() {
    		//调用父类的方法
    		super.sayHi();
    		System.out.println("我来sayhi");
    	}	
    }
    public class Test {
    
    	public static void main(String[] args) {
    		Student s = new Student();
    		
    		s.test();
    		s.sayHi();		
    	}
    }

7.4super与this

>  *  this或super使用在构造方法中时，都要求在首行。
>  *  当子类构造中使用了this()或this(实参)，即不可再同时书写super()或super(实参)，会由this()指向z构造方法完成super()调用。

案例:

public class Person {
    	String name="person";
    
    	public Person() {
    		System.out.println("这个是 Person的无参构造方法");
    	}
    	public Person(String name ) {
    		System.out.println("这个是 Person的有参构造方法,参数:"+this.name);
    	}
    	public Person(String name,int a ) {
    		System.out.println("这个是 Person的有参构造方法,参数:"+this.name);
    	}
    	
    }
    
    public class Student extends Person {
    
    	String name = "student";
    
    	public Student(String name) {
    		/*
    		 * 不管是this还是super都必须是第一行,所以在构造方法中,只能调用其中之一
    		 */
    //		this();
    //		super("xxx",1);         //调用父类的有参构造方法
    //      super();                //调用父类的无参构造方法
    //		System.out.println(super);
    //		System.out.println(this);
    		System.out.println("这个是student的有参构造方法");
    		this.name = name;
    	}
    	public Student() {
    		this("名字");
    		//没有显式的写super(),就会默认调用父类的无参构造方法==>super()
    		System.out.println("这个是student的无参构造方法");
    	}
    }
    
    public class Test {
    
    	public static void main(String[] args) {
    		new Student();
    	}
    
    }

## 三.多态 ##

### 3.1多态 ###

概念：父类引用指向子类对象，从而产生多种形态。

> 二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态。

> 父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

### 3.2多态的应用 ###

>  *  场景一：使用父类作为方法形参实现多态，使方法参数的类型更为宽泛。
>  *  场景二：使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。

案例：

public class Animal {	                       //动物类（父类）
    	public void eat() {
    
    		System.out.println("吃吃吃");
    	}
    }
    
    public class Cat extends Animal{              //猫类继承动物类
    	public  void eat() { 
    
            System.out.println("吃老鼠");
    	}
    	public void cry() {
    
    		System.out.println("喵哦");
    	}
    }
    
    public class Dog extends Animal{              //狗类继承动物类
    	public void eat() {
    		System.out.println("吃肉肉");
    	}
    }
    public class Fish extends Animal{             //鱼类继承动物类
    	public void eat() {
    		
    		System.out.println("吃小虾米");
    	}
    	public  void swim() {
    
    		System.out.println("我要游泳");
    	}
    }
    
    public class Snake extends Animal{            //蛇类继承动物类
    	@Override
    	public void eat() {
    
    		System.out.println("蛇吞象");
    }
    	public void pa() {
    
    		System.out.println("我要爬走");
    	}
    }
    
    public class Master {                        //主人类
    
    		public void eat(Animal animal) {
    			System.out.println("mater喂食");
    			animal.eat();
    		}
    }
    
    //使用父类作为方法返回值实现多态
    import java.util.Scanner;
    public class Petshop {                      //petshop类           
    	Scanner sc=new  Scanner(System.in);
    		
    	public Animal sell (int num) {
    			
    		Animal animal=null;
    		if (num==1) {
    			animal=new Dog();
    		}else if (num==2) {
    			animal=new Cat();
    		}else if (num==3) {
    			animal =new Fish();
    		}else {
    			animal =new Snake();
    		}
    		return animal;
    	}
    	public void shouMenu() {                       //显示菜单
    	
    		System.out.println("狗-1 猫-2 鱼-3 蛇-4");
    		System.out.println("请输入数字");
    		int num1=sc.nextInt();
    		
    		Animal animal=sell(num1);
    		
    		Master m=new Master();
    		m.eat(animal);
    		
    		if (animal instanceof Dog) {
    			Dog g=(Dog) animal;
    			g.eat();
    		}else if(animal instanceof Cat) {
    			Cat c=(Cat)animal;
    			c.cry();
    		}else if(animal instanceof Fish) {
    			Fish f=(Fish)animal; 
    			f.swim();
    		}else if(animal instanceof Snake) {
    			Snake s=(Snake)animal;
    			s.pa();
    		}
    		
    	}
    }
    
    public class Text {                            //测试类
    
    	public static void main(String[] args) {
    		
    		Petshop p=new Petshop();
    		p.shouMenu();	
    	}
    }

### 3.4instance of关键字 ###

>  *  向下转型前，应判断引用中的对象真实类型，保证类型转换的正确性。
>  *  语法：父类引用 instance of 类型 //返回boolean类型结果

代码：

public class Animal {
    	public void eat() {
    
    		System.out.println("吃吃吃");
    	}
    }
    
    public class Cat extends Animal{
    @Override
    public void eat() {
    	// TODO Auto-generated method stub
    	System.out.println("吃喵粮");
    }
    }
    
    public class Dog extends Animal{
    @Override
    public void eat() {
    	// TODO Auto-generated method stub
    	System.out.println("吃狗粮");
    }
    }
    
    public class Test {
    
    	public static void main(String[] args) {      //输出：吃狗粮
    		Animal a=new Dog();
    		if (a instanceof Dog) { 
    			Dog dog=(Dog)a;
    			dog.eat();  
    		}else if(a instanceof Cat) {
    			Cat cat=(Cat)a;
    			cat.eat();
    		}
    	}
    }