JAVA学习笔记25（面向对象编程（高级））

1.4 final关键字

*final可以修饰类、属性、方法和局部变量

1.可能会用到final关键字

1.当不希望类被继承时，可以用final修饰

final class A{ }

2.当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰

【访问修饰符 final 返回类型方法名】

class C{//使用final修饰 hi方法，不允许重写public final void hi(){}
}class D extends C{@Overridepublic void hi(){System.out.println("重写了C类的hi方法")}
}

3.当不希望类的某个属性的值被修改，可以用final修饰

【public final double TAX_RATE = 0.08】

4.当不希望某个局部变量被修改，可以使用final修饰

class F{public void cry(){final double Num = 0.01;Num = 0.9;	//错误，不允许修改}
}

2.注意事项和细节

1.final修饰的属性又叫常量，一般用 XX_XX_XX 来命名

2.final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一

1）定义时：如public final double TAX_RATE = 0.08;

2）在构造器中

3）在代码块中

class AA{public final double TAX_RATE = 0.08;public final double TAX_RATE2;public final double TAX_RATE3;public AA(){TAX_RATE2 = 1.1;}{//在代码块赋值TAX_RATE3 = 8.8;}
}

3.如果final修饰的属性是静态的，则初始化的位置只能是

1）定义时 2）在静态代码块不能在构造器中赋值

class BB{public static final double TAX_RATE = 99.9;public static final double TAX_RATE2;static {TAX_RATE2 = 3.3; }
}

4.final类不能继承，但是可以实例化对象

5.如果类不是final类，但是含有final方法，则该方法虽然不能重写，但可以被继承

6.一般来说，如果一个类已经是final类了，就没有必要再将方法修饰词final方法

7.final不能修饰构造方法(即构造器)

8.final和 static往往搭配使用，效率更高，调用时不会导致类加载（不会调用类里面的其它静态函数和其它静态数据），底层编译器做了优化处理

class Demo{public static final int i =16;static{System.out.println("hsp");}
}

9.包装类(Integer,Double,Float,Boolean等都是final)，String也是final类，不能被继承

1.5 抽象类

*当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类

*一般来说，抽象类会被继承，由其子类来实现抽象方法

class AA{//当一个类中存在抽象方法时，需要将该类声明为abstract类public abstract void eat() ;
}

1.抽象类的介绍

1.用abstract关键字来修饰一个类时，这个类就叫抽象类

访问修饰符 absract 类名{
}

2.用abstract关键字来修饰一个方法时，这个方法就是抽象方法

访问修饰符 abstract 返回类型方法名(参数列表)

3.抽象类的价值更多作用是设计，设计好之后让子类继承并实现抽象类

2.抽象类使用细节

1.抽象类不能被实例化

2.抽象类不一定要包含abstract方法，也就是说，抽象类可以没有abstract方法

3.一旦类包含了abstract方法，则这个类必须声明为abstract

4.abstract只能修饰类和方法，不能修饰属性和其它的

5.抽象类可以有任意成员【抽象类还是类】，比如：非抽象方法、构造器、静态属性

6.抽象方法不能有主体(函数体)，即不能实现

7.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

8.抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的

1.6 接口

*接口(interface)

public interface UsbInterface{//接口//规定接口的相关方法public void start();public void stop();
}//Phone 类 实现 UsbInterface
//即Phone 类需要实现UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{@Overridepublic void start(){System.out.println("手机开始工作")}@Overridepublic void stop(){System.out.println("手机停止工作")}
}public class Camer implements UsbInterface{	//实现接口，就是把规定好的方法实现@Overridepublic void start(){System.out.println("相机开始工作")}@Overridepublic void stop(){System.out.println("相机停止工作")}
}public class Computer{//编写一个方法,计算机工作public void work(UsbInterface usbInterface){//通过接口，调用方法usbInterface.start();usbInterface.stop();}
}public class nterface01{public static void main(String[] args){Camera camera = new Camera();Phone phone = new Phone();//创建计算机Computer computer = new Computer();computer.work(phone);//把手机接入到计算机System.out.println("=======");computer.work(camera);//把相机接入到计算机}
}

1.基本介绍

*接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来，语法：

interface 接口名{//属性//方法（1.抽象方法 2.默认实现方法(default) 3.静态方法(static)）
}
class 类名 implements 接口{自己属性;自己方法;必须实现的接口的抽象方法;
}

*在接口中，抽象方法，可以省略abstract关键字

*如果要在interface中书写方法体，必须是默认方法default或者静态方法static

2.注意事项及理解

1.接口不能被实例化，接口本身是一个抽象化

2.接口中所有的方法是public方法，接口中的抽象方法，可以不用abstract修饰

3.一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用alt+enter来快速写入接口方法模板

4.抽象类实现接口，可以不用实现接口的方法

5.一个类同时可以实现多个接口

interface IB{}
interface IC{}class Pig implements IB,IC{}

6.接口中的属性，只能是final的，而且是public static final修饰符，

比如： int a = 1;实际上是 public static final int a =1;

7.接口中属性的访问形式：

接口名.属性名

8.一个接口不能继承其它的类，但是可以继承多个别的接口(接口和接口是继承的关系extends)

interface A extends B,C{}

9.接口的修饰符，只能是public和默认(default)，这点和类的修饰符是一样的

3.接口和继承

1.接口和继承解决的问题不同

*继承的价值主要在于：解决代码的复用性和可维护性

*接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法，即更加的灵活

2.接口比继承更加灵活

继承是满足is - a的关系，而接口只需要满足like - a的关系

3.接口在一定程度上实现代码解耦

即接口规范性+动态绑定

4.接口的多态

1.接口的多态特性

*多态参数

例如USB接口案例，既可以接收手机对象，又可以接收相机对象，体现了接口多态

main()
{//接口多态的体现//接口类型的变量 if01 可以指向 实现了IF接口类的对象实例If if01 = new Monster();if01 = new Car();
}interface IF{}
class Monster implements IF{}
class Car implements IF{}

*多态数组

main()
{Usb[] usbs = new Usb[2];usbs[0] = new Phone_();usbs[1] = new Camera_();//Usb数组中，存放phone和camera对象，Phone类还有一个特有的方法call(),//请遍历usb数组，如果是Phone对象 ，还要调用方法callfor(int i =0;i<usbs.length;i++){
usbs[i].work();if(usbs[i] instanceof Phone_){((Phone_) usbs[i]).call();}}
}interface Usb{void work();
}class Phone_{public void call(){System.out.println("手机打电话")}@Overridepublic void work(){System.out.println("手机工作中")}
}class Camera_ implements Usb{@Overridepublic void work(){System.out.println("相机工作中")}}

*接口存在多态传递现象

main()
{IG ig = new Teacher();//如果IG继承了IH接口，而Teacher实现了IG接口//那么，实际上就相当于Teacher类也实现了IH接口//这就是所谓的接口多态传递现象IH ih = new Teacher();
}interface IH{}
interface IG extends IH{}
class Teacher implements IG{}

1.7 内部类

*一个类的内部又完整的嵌套了另一个类的结构，被嵌套的类被称为内部类(inner class),嵌套其他的类的类被称为外部类(outer class)。是我们类的五大成员【属性、方法、构造器、代码块、内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现雷雨类直接的包含关系

1.基本语法

class Outer{	//外部类class Inner{	//内部类}
}
class Other{	//外部其他类}

2.内部类的分类

1.定义在外部类局部位置上(比如方法内)

*局部内部类(有类名)

*局部内部类是定义在外部类的局部位置，比如方法中，并且有类名

1.可以直接访问外部类的所有成员，包括私有的

2.不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的，但是可以用final修饰，因为局部变量也可以使用final

3.作用域：仅仅在定义它的方法或代码块中

4.局部内部类–访问—>外部类的成员[访问方式：直接访问]

5.外部类–访问—>局部内部类的成员

访问方式：创建对象，再访问(注意：必须在作用域内)

6.外部其他类—不能访问—局部内部类(因为局部内部类地位是一个局部变量)

7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

System.out.println(“外部类的n2=” + 外部类名.this.n2)

class Outer02{private int n1 = 100;public void m1(){//局部内部类是定义在外部类的局部位置，通常在方法class Inner02{//局部内部类(本质仍然是一个类)public void f1(){System.out.println("n1=" + n1);}}}Inner02 inner02 = new Inner02();inner02.fi();
}

*匿名内部类(没有类名)

*匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

*1.本质是类 2.内部类 3.该类没有名字 4.同时还是一个对象

*匿名内部类的基本语法

new 类或接口(参数列表){类体
};

class Outer04{private int n1 = 10;//属性public void method(){//方法//基于接口的匿名内部类//1.需求：想使用IA接口，并创建对象//2.传统方式，是写一个类，实现该接口，并创建对象//3.使用匿名内部类简化开发//4.tiger的编译类型为IA//5.tiger的运行类型为匿名内部类//底层/*底层会给匿名内部类分配类名class XXX implements IA{@Overridepublic void cry(){
System.out.println("老虎叫唤...")}}*///6.匿名内部类使用一次，就不能再使用//7.jdk底层在创建匿名内部类Outer04￥1,立即就创建了Outer04$1实例，并且把地址返回给tigerIA tiger = new IA(){@Overridepublic void cry(){System.out.println("老虎叫唤。。。")}};tiger.cry();}//基于类的匿名内部类//father编译类型 Father//father运行类型 Outer04$2/*class Outer04$2 extends Father{@Overridepublic void test(){System.out.println("匿名内部类重写了test方法")}    	}*///4.同时也直接返回了匿名内部类Outer04$2的对象Father father = new Father("jack"){@Overridepublic void test(){System.out.println("匿名内部类重写了test方法")}};father.test();//基于抽象类的匿名内部类Animal animal = new Animal(){@Overridevoid eat(){System.out.println("小狗吃骨头")	}};animal.eat();}
}interface IA{public void cry();
}class Father{public Father(String name){//构造器}public void test(){//方法}
}abstract class Animal{abstract public void eat();
}

*匿名内部类细节：

1.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵守就近原则

2.如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

3.匿名内部类可以直接调用外部类成员

4.外部其他类–不能访问—>匿名内部类

class Outer{class Inner{Person p = new Person(){@Overridepublic void hi(){System.out.println("匿名内部类重写了hi方法");}};p.hi();//也可以直接调用new Person(){@Overridepublic void hi(){System.out.println("匿名内部类重写了hi方法,hhh");}@Overridepublic void ok(String str){super.ok(str);}}.hi();.ok("jack")
}class Person
{public void hi(){}public void ok(String str){System.out.println(str)}
}

*匿名内部类实践

main()
{//匿名内部类当做实参直接传递f1(new IL(){@Overridepublic void show(){System.out.println("这是一幅名画")}});//静态方法，形参是接口类型public static void f1(IL il){il.show();}
}
//接口
interface IL{void show();
}

2.定义在外部类的成员位置上

*成员内部类(没用static修饰)

*成员内部类是定义在外部类的成员位置，并且没有static修饰

1.可以直接访问外部类的所有成员，包含私有的

2.可以添加任意访问修饰符(public, protected,默认，private)，因为它的地位就是一个成员

3.和外部类的其他成员一样，作用域为整个类体，在外部类的成员方法中创建成员内部类对象，再调用方法

4.成员内部类–访问—>外部类【访问方式：直接访问】

5.外部类–访问—>内部类【访问方式：创建对象，再访问】

6.外部其他类–访问–>成员内部类

用它外部类.内部类new一个对象，再去访问

7.如果外部类和成员内部类的成员重名时，成员内部类访问的话，默认遵守就近原则

8.如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

main()
{Outer08.Inner08 inner08 = outer08.new Inner08();
}class Outer08
{class Inner098{}
}

class Outer08{private int n1 = 10;//成员内部类，是定义在外部类的成员位置上class Inner08{public void say(){System.out.println("n1="+n1);}}//写方法public void t1(){Inner08 inner08 = new Inner08();inner08.say();}}

*静态内部类(使用static修饰)

*静态内部了已定义在外部类的成员位置，并且有static修饰

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2.可以添加任意访问修饰符(public, protected, 默认 , private)，因为它的地位就是一个成员

3.作用域：同其他的成员，为整个类体

4.静态内部类–访问—>外部类（比如静态属性）【直接访问】

5.外部类–访问—>静态内部类【访问方式：创建对象，再访问】

6.外部其他类–访问—>静态内部类【类似成员内部类】

7.如果外部类和静态内部类的成员重名时，静态内部类访问的话，默认遵守就近原则

8.如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

//方式1Outer10.Inner10 inner10 = new Outer10.Inner10();inner10.say();//方式2
Outer10.Inner10 inner10 = outer10.getInner10;

class Outer
{private int n1 = 10;private static String name = "张三";static class Inner10{public void say(){System.out.println(name);}}public Inner10 getInner10(){return new Inner10();}
}