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

发布于：2024-04-22 ⋅ 阅读:(139) ⋅ 点赞:(0)

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{
    @Override
    public 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{
    
    @Override
    public void start(){
        System.out.println("手机开始工作")
    }

    @Override
    public void stop(){
        System.out.println("手机停止工作")
    }
}

public class Camer implements UsbInterface{	//实现接口，就是把规定好的方法实现
    
    @Override
    public void start(){
        System.out.println("相机开始工作")
    }

    @Override
    public 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对象 ，还要调用方法call
    for(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("手机打电话")
            
    }
    
    @Override
    public void work(){
        System.out.println("手机工作中")
    }
}

class Camera_ implements Usb{
    @Override
    public 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{
        @Override
        public void cry(){
System.out.println("老虎叫唤...")}
        }
        */
        //6.匿名内部类使用一次，就不能再使用
        //7.jdk底层在创建匿名内部类Outer04￥1,立即就创建了Outer04$1实例，并且把地址返回给tiger
        IA tiger = new IA(){
            @Override
            public void cry(){
                System.out.println("老虎叫唤。。。")
            }
        };
        tiger.cry();
            
        }
    //基于类的匿名内部类
    //father编译类型 Father
    //father运行类型 Outer04$2
    /*
    	class Outer04$2 extends Father{
		@Override
        public void test(){
            System.out.println("匿名内部类重写了test方法")
        }    	
    	}
    */
    //4.同时也直接返回了匿名内部类Outer04$2的对象
    Father father = new Father("jack"){
		@Override
        public void test(){
            System.out.println("匿名内部类重写了test方法")
        }
    };
    father.test();
    
    //基于抽象类的匿名内部类
    Animal animal = new Animal(){
        @Override
        void 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(){
          	@Override
            public void hi(){
                System.out.println("匿名内部类重写了hi方法");
            }
        };
        p.hi();
        
        //也可以直接调用
        new Person(){
          	@Override
            public void hi(){
                System.out.println("匿名内部类重写了hi方法,hhh");
        }
            @Override
            public 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(){
        @Override
        public 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.成员)去访问

//方式1

Outer10.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();
    }
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布