关于java封装,继承,多态,this,super关键字超详解

封装

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

  public class Demo{
		private String name;         
		public String getName (){ 
			return name;
		}    
		public void setName(String name){
		                                                   			this.name = name;
              	}
         } 

具体表现
属性使用private权限
方法使用public权限

封装的好处：1.隐藏类的实现细节

2.方便加入控制语句

3.方便实现修改

4.只能通过规定方法访问

this关键字

this关键字代表自身类的对象
使用this关键字引用成员变量
使用this关键字引用成员方法
注意：this关键字必须放在非静态方法里面

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class Demo{
	private int a;
			
	public Demo(int a){
	    this.a = a;
	}
			
	public int getA(){
		return a;
	}
			
	public void setA(int a){
		this.a = a;
	}
}

继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。
使用extends关键字来表示继承关系。
java不支持多继承，单继承使java的继承关系很简单，一个类只能有一个直接父类。
继承之后子类可以调用父类的所有非私有属性和非私有方法
Java只支持单继承，实现多重继承三种方式：（1）直接实现多个接口 （2）扩展(extends)一个类然后实现一个或多个接口 （3）通过内部类去继承其他类

继承的形式：
[访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}

public class Animal{
	public void eat(){}
}

public class Dog  extends Animal{
	public void play(){} 
}

//子类对象可以直接调用父类的方法，强调复用性
 Dog  dog = new Dog ();
     dog.eat();

继承的传递性
1.C类从B类继承,B类又从A类继承
那么C类就具有B类和A类的所有非私有属性和非私有方法
2.当一个没有继承任何一个类时,jvm会默认让类继承Object类
Object是 java为所有类提供的基类

super关键字用途

super关键字代表父类的引用，在程序中主要的用途
在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。
用“super.成员变量名”来引用父类成员变量
用“super.方法名（参数列表）”的方式访问父类的方法。
与this的区别，this通常指代当前对象，super通常指代父类。

class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
super.move(); // 应用super类的方法
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal b = new Dog(); // Dog 对象
b.move(); //执行 Dog类的方法
}
}

多态

多态：同一种事物，在不同时刻表现不同的状态
多态存在的三个必要条件
1.要有继承（包括接口的实现）(前提条件)
2.要有重写(前提条件)
3.父类引用指向子类对象

1.多态环境下对成员方法的调用

class  Animal{
           void show() {
             System.out.println(“Anmial");
          }
}
class Cat  extends Animal{
              void show() {
                    System.out.println(“cat");
              }
}
…….
Animal x = new Cat() 
   x.show() //调用的是子类中的方法

简单的来说，编译看左边，运行看右边

2.多态环境下对静态成员方法的调用

class  Animal{
          static  void show() {
             System.out.println(“Animal");
          }
}
class Cat extends Animal {
             static  void show() {
                    System.out.println(“Cat");
              }
}
…….
Animal x = new Cat() 
   x.show() ;调用的是动物类中的静态成员方法。

3.多态环境下对成员变量的调用

class Animal{
       int num = 3;
}
class Cat  extends Animal {
       int  num = 4;
}
…….
Animal x = new Cat() 
x.num; 调用的是动物类中的成员变量。

4.方法参数具有多态性

class  Animal{
           void eat() {}
}
class  Cat extends Animal{
            void eat() {}
}
class Dog extends Animal{
            void eat(){}
}
方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象
method(Animal  animal){  
     animal .eat();                
}

5.向上转型：提高程序的扩展性
缺点: 父类类型不能访问子类中特有的方法

class Animal{
   void eat(){ }
}
class Cat extends Animal{
      void look() {
	System.out.println("看家");
	 }
    }      
 ………
   Animal x=new Cat()  向上造型，Cat对象提升到Animal对象
   x.eat()   只能使用父类中的方法
   x.look()  报错！不能使用子类中的方法

6.向下转型：为了使用子类中的特有方法

class Animal{
      void eat(){ }
}
class Cat extendsAnimal{
      void look() {
          System.out.println("看家");
      }
    }      
 ………
Animal x=new Cat()
Cat  m=(Cat)x;  向下转型
   m.eat() ;
   m.look(); 子父类中的方法都可以使用

instanceof
instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
左边的对象实例不能是基础数据类型