JAVA基础_封装，继承，多态

1.Java的封装隐藏实现

• 先把属性设置声明为私有的，用private关键字进行声明
• 通过编写public类型的setXxx()和getXxx()方法来设置属性和获取属性

public class Person {

//	public int age;
//像这种情况，是把类的属性开发出来，让调用者随意使用，这样会有问题
	
	//我们需要对这样不能让调用者随意使用的属性做封装和隐藏
	private int age;
	
	public void printAge(){
		System.out.println("年龄是：" + age);
	}
	
	public int getAge(){
		return age;
	}
	
	public void setAge(int a){
		if(a <= 130 && a >= 0){
			age = a;
		}else{
			System.out.println("输入的年龄：" + a + " 不在0到150之间");
		}
	}
}

• 然后建立主函数设置年龄以及获取年龄实现对年龄的封装和隐藏

public class Test {
	public static void main(String[] args) {
		Person p = new Person();
		p.setAge(22);
		p4.getAge();
	}
}

2.四种访问权限修饰符

• Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。 

                                       

• 对于class类的权限修饰只可以用public和default(缺省)。

  public 类可以在任意地方被访问。
  default 类只可以被同一个包内部的类访问。

注意：在同一个java文件中可以写多个java类，但至多有一个public类型的类，其他类型只能缺省，即不写修饰符。

3.类的构造方法

• new对象实际上就是调用类的构造方法，在未自定义构造函数时，系统在new对象时，会默认调用无参构造函数
• 使用this()的方式也是可以调用类的构造函数，如this("zhangsan");需注意的是使用this()必须放在构造器的首行

class Person{		// 定义Person类
	private String name ;		
	private int age ;			
	public Person(){	  // 无参构造
		System.out.println("新对象实例化") ;
	}
	public Person(String name){
		this();      // 调用本类中的无参构造方法
		this.name = name ;	
	}
	public Person(String name,int age){	
		this(name) ;  // 调用有一个参数的构造方法
		this.age = age;
	}
	public String getInfo(){	
		return "姓名：" + name + "，年龄：" + age ;
	}  }

4.JavaBean

• JavaBean是一种Java语言写成的可重用组件
• javaBean是指符合如下标准的Java类

类是公共的

有一个无参的公共的构造器

有属性，属性一般是私有的，且有对应的 get 、 set 方法

public class TestJavaBean{
      private String name;  //属性一般定义为private
      private int age;
      public  TestJavaBean(){}
      public int getAge(){
             return age;
      }
      public void setAge(int age){
             this.age = age;
      }
      public String getName(){
            return name;
      }
      public void setName(String name){
            this.name = name;
}

5.继承

• 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

public class Person {
      public String name;
      public int age;
      public String getInfo() {...}
}

public class Student extends Person{
      public String school;
}
//Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person中的属性和方法,Student都可以利用。

• 子类继承了父类，就继承了父类的方法和属性
• 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法
• 子类不是父类的子集，而是对父类的“扩展”
• 子类不能直接访问父类中私有的(private)的成员变量和方法

                                                                    

• Java只支持单继承，不允许多重继承

  一个子类只能有一个父类

  一个父类可以派生出多个子类

                                          

 

6.super关键字

• 在Java类中使用super来调用父类中的指定操作：

super 可用于访问父类中定义的属性

super 可用于调用父类中定义的成员方法

super 可用于在子类构造方法中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用 super 进行区分

super 的追溯不仅限于直接父类，还可以是父类的父类一直到根父类

super 和 this 的用法相像， this 代表本类对象的引用， super 代表父类的内存空间的标识

7.super和this区别联系

                              

8.多态

• 多态指的是同一个方法调用，由于对象不同可能会有不同的行为。

例如：

 Animal a1 = new Cat(); 
 animalCry(a1);
 Animal a2 = new Dog();
 animalCry(a2);
//animalCry(a1)和animalCry(a2)就是多态的两种体现

多态的要点：

      1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

      2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

      3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵！");
    }
}
public class TestPolym {
    public static void main(String[] args) {
        Animal a1 = new Cat(); // 向上可以自动转型
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
        animalCry(a1);
        Animal a2 = new Dog();
        animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
         
        //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
        // 否则通不过编译器的检查。
        Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();
    }
 
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    static void animalCry(Animal a) {
        a.shout();
    }
 
    /* 如果没有多态，我们这里需要写很多重载的方法。
     * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
    static void animalCry(Dog d) {
        d.shout();
    }
    static void animalCry(Cat c) {
        c.shout();
    }*/
}