Java学习之路-day14

接着昨天的多态知识点总结：
1.instanceof 对象类型的校验，将返回一个boolean值

Instanceof 对类型进行判断  
Animal animal = new Cat();
animal instanceof Cat//判断创建的animal是否为Cat
animal instanceof Dog
对象 instanceof 类型 【将返回一个booean类型】
判断前面的对象，可不可以作为后面类型的实例

对象当中的成员方法—》堆当中的成员方法，保存的是一个【地址值】，指向了方法区的成员方法

例：
givePet(new Dog());
public static void givePet(Animal animal){
	if(animal instanceof Dog){//判断animal是不是Dog
		Dog dog =(Dog)animal;//进行向下转型
		dog.watchHouse();
	}
	if(animal instanceof Cat){
		Cat cat = (Cat)animal;
		cat.catchMouse();
	}
}

例：useDevice(USB usb);
实现类可以向上转型成为接口类型---》从小到大，自动安全的进行转换
USB usbMouse = new Mouse();//向上转型
lopTop.useDevice(usbMouse);
Keyboard keyboard = new Keyboard();
lopTop.useDevice(keyboard);//从范围小到范围大的，自动安全的进行向上转型
lopTop.useDevice(new Keyboard());

2、final关键字：代表最终的，不可改变的
【1】修饰一个类
格式：

public final class 类名称{
	//.....
}

【a】当前这个类（使用final修饰）不能有任何的子类。即不能被继承，但是该类可以向上继承父类
【b】不能使用一个final类来作为父类
【c】使用final修饰后，其中的成员方法不能被覆盖重写，因为没有子类；

public final class MyClass extends Object{
	public void methodFinal(){//不能被覆盖重写
		System.out.println("final修饰的类");//因为没有子类，所以成员方法不能被覆盖重写
	}
}

【2】修饰一个方法
格式：
修饰符 final 返回值类型 方法名称(参数列表){
//方法体
}

public final void methodA(){
	System.out.println("用final修饰的成员方法methodA");
	}

【注意】当final关键字来修饰一个方法的时候，这个方法就是最终方法，不可以进行覆盖重写；

public class Fu{
public void method(){
	System.out.println("父类的成员方法");
}
	public final void methodA(){
	System.out.println("用final修饰的成员方法methodA");
	}
}
public class Zi extends Fu{
	public void method(){//子类对父类方法进行了覆盖重写
	System.out.println("子类方法");
	}
	@override//final修饰的方法，子类不能进行覆盖重写，编译会报错
	public  void methodA(){
	System.out.println("用final修饰的成员方法methodA");
	}
}

对于类和方法，abstract和final不能同时使用，因为是相互矛盾的；abstract抽象方法必须进行覆盖重写，但是final是不可以进行覆盖重写的，两者在一起使用会冲突；
public abstract void method();//正确写法 子类必须覆盖重写
public final void method(){}//正确写法 因为是最后的方法，不能进行覆盖重写
public abstract final void method(){}//错误写法 abstract是必须进行覆盖，final不能进行覆盖
【3】修饰一个局部变量
使用final进行修饰的局部变量，一旦赋值就不能在改变；只能一次赋值，永不改变；
final int num = 20;
int num = 20;就算再次赋同样的值，也是进行了二次赋值，编译会报错
【注意】
【a】
final int num3;
num3 = 30;//正确写法
//num3先定义在进行赋值，是正确的，如果不赋值，将自动赋值默认值，之后就不可再进行改变，所以使用final修饰的变量必须进行手动的赋值操作；
【b】对于基本数据类型来说，不可变的是变量当中的数值不可变；
对于引用数据类型来说，不可变的是变量当中的地址值不可变；

final Student stu = new Student("A");
stu = new Student("B");//错误写法，final的引用类型变量，其中的地址不可改变
stu.setName("AA");//正确写法 可以赋值

【4】修饰一个成员变量
对成员变量来说，如果使用final关键字进行修饰，那么这个变量也是不可改变的；
【a】由于成员变量具有默认值，一旦用了final之后，必须手动赋值
不会再给默认值了
private final String name;//因为没有进行赋值，默认值为null
【b】对于final的成员变量，要么【使用直接赋值，要么间接通过构造方法赋值】二者选其一；
private final String name = “鹿晗”;//对其进行直接赋值
//this.name = name;setter()方法当中的赋值语句就会报错，因为final修饰的成员变量一旦赋值，就不能改变；
//使用构造方法进行赋值，必须保证所有的构造方法都要进行赋值
//如果是单一赋值，程序会报错
public Person(){
name = “A”;
}
public Person(String name){
this.name = name;
}
//使用了构造方法对final修饰的成员变进行赋值，必须保证所有的构造方法都要对该成员变量进行赋值操作，否则编译报错
【c】必须保证所有的重载的构造方法，都对final修饰的成员变量进行赋值；
3、四种权限修饰符：
default是可以省略的

    		public >    protected >  (default) >      private

同一类		  OK		OK	    OK	      OK
同一包		  OK	     OK                  OK
不同包子类	  OK		OK
不同包非子类	  OK

例：同一包不同类之间的访问：
public class MyAnother{
	public void antherMethod(){
		System.out.println(new MyClass().num);
		System.out.println(new MyClass().num1);//报错
	}
}
public class MyClass{
	int num = 10;
	private int num1 = 20
}

4、内部类
一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类；
【1】成员内部类
成员内部类格式：
修饰符 class 类名称{//外部类
修饰符class类名称{//内部类
}
}
【注意】内用外，随意使用，但是外用内，就需要内部对象

public class Outter{
	public class Inner{//定义在方法外，成员内部类
	//内部类的方法
	public void methodInner()
	{
			}
	}
	//外部类的方法
	public void methodOutter(){
	new Inner.methodInner();//使用内部类的方法
	}
}

【2】访问方式
【a】直接访问

【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
Outter.Inner methodInnerA = new Outter().new Inner();
methodInnerA.methodInner();

【b】间接访问：通过定义外部类的对象，来调用外部类的成员方法，从而间接的使用内部类的成员方法；

public class DemoInnerClass{
	public static void main(String[]args){
	Outter outter = new Outter();
	outter.methodOutter();
	//通过外部类的对象，调用外部的方法，然后里面间接在使用内部类Inner中的方法
	}
}

【内类和外部类的字节码文件格式】
Outter.class 外部类class文件
Outter$Inner.class 内部类class文件
【c】内部类的同名变量

public class Outer{
	int num = 10;//外部类的成员变量
	public class Inner{
	int num = 20;//内部类的成员变量
	public void methodInner(){
		int num = 30;//内部类方法的局部变量
		System.out.println(num);//局部变量，就近原则，访问内部类的局部变量
		System.out.println(this.num);//内部类的成员变量，访问内部类的成员变量
		System.out.prinln(super.num);//错误写法
		//因为内外部类之间没有继承关系，不能使用super关键字
		System.out.prinln(Outer.this.num);//外部类的成员变量
		//外部类名称.this.外部类的成员变量名————  实现对外部类的成员变量的调用
	}
	}
}

由于内外部类的知识还没有学习完，明日继续更新这部分的知识点，余留的作业明天做完，整理一下问题笔记，总结之前的知识点，多练习多敲代码。学习之路-共勉 以马内利