Java的第一遍学习笔记面向对象高级

最新推荐文章于 2024-05-16 10:23:10 发布

Acc222222

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量219

点赞数 1

分类专栏：学习笔记文章标签： java

本文链接：https://blog.csdn.net/Acc222222/article/details/120377599

版权

学习笔记专栏收录该内容

26 篇文章 2 订阅

订阅专栏

final

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

使用

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

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

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

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

     public void test(){
         final int a = 10;
         a= 20;   //报错
     }

注意事项

1. final修饰的属性又叫常量，一般用 XX_XX_XX命名（比如 TAX_RATE）。

public final static TAX_RATE = 0.2;

2. final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在下列位置之一：(1)定义时 (2) 在构造器中 (3) 在代码块中（代码块相当于构造器的补充）

3. 如果final修饰的属性是静态的，则初始化位置只能是：(1) 定义时 (2) 在静态代码块，不能在构造器中赋值（因为可以用类名调用静态属性，并没有调用构造器）。

4. final类不能继承，但是可以创建对象（实例化）。

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

    public static void main(String[] args) {
        Student a = new Student();
        a.test();  //输出父类的test方法
    }

6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法（因为根本就无法继承，也就没办法重写方法了）。

7. final不能修饰构造器。

8. final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理。

public class Person {
     public final static double PI = 3.14;
     static{
         System.out.println("类加载，调用静态代码块");
     }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Person.PI);   //只输出 3.14，不调用静态代码块
    }
}

9. 包装类（Integer,Double,Float,Boolean等）都是final，String也是final类。

抽象类

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

abstract public class Person {
     public abstract void say();  //加分号
}

所谓抽象方法就是没有实现的方法（没有方法体），当一个类中存在抽象方法时，需要将该类声明为abstract方法。一般来说，抽象类会被继承，由其子类来实现抽象方法。

简介

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

访问修饰符 abstract 类名{}

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

访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体

3. 抽象类的价值更多作用是在于设计，设计者设计好后，让子类继承并实现抽象类，在框架和设计模式使用较多（常考）。

注意事项

1. 抽象类不能被实例化。

2. 抽象类可以没有abstract方法，但只要类是abstract，那么它的方法即使不写abstract，也是抽象方法。

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

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

5. 抽象类可以有任意成员（因为抽象类还是类），比如：非抽象方法，构造器，静态属性等等。

6. 抽象方法不能有主体，即不能有大括号。

     public abstract void say(){}; //报错，不能有大括号

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

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

private不能重写，static与重写无关。

关于static可以看这个博客：关于abstract为什么不能和static连用_sinat_36695865的博客-CSDN博客

模板设计模式

abstract public class Template { //抽象类-模板设计模式
    public abstract void job(); //抽象方法
    public void calculateTime(){  //主体方法
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("执行时间为:"+(end-start));
    }
}

public class AA extends Template{
    @Override
    public void job() {   //重写抽象方法
        int sum = 0;
        for (int i = 0; i < 1000000; i++) {
            sum += i;
        }
    }
}

public class Test {
    public static void main(String[] args) {
         AA a = new AA();
         a.calculateTime();  //直接调用方法
    }
}

这个设计模式的好处就是 —— 把需要重写的方法做成抽象方法写在抽象父类中，子类只需要把不同的代码重写即可，相同部分的方法写在抽象类中，子类不需要动，在测试类中实例化对象直接调用即可。

接口

基本介绍

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

interface 接口名{
    //属性
    //方法(1.抽象方法 2.默认实现方法 3.静态方法)
}

class 类名 implements 接口名{
    //自己的属性
    //自己的方法
    //必须实现的接口抽象方法
}

注：1. 在Jdk7.0 之前，接口里的所有方法都没有方法体，即都是抽象方法（abstract可省略）。2. Jdk8.0 后，接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现。

public interface Interface01 {
    public int n1 = 10;
    public void h1();   //接口中可省略abstract
    default public void say(){  //默认方法，要加上关键字default
        System.out.println("调用say方法");
    }
    public static void hi(){   //静态方法
        System.out.println("打招呼");
    }
}

注意事项

1. 接口不能被实例化。

Interface01 a = new Interface01(); //报错

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

void h1();  //实际上是 public abstract void h1();

如何验证：

public class Teacher implements Interface01{
    @Override
    void h1() {}   //报错，因为根据继承关系，重写方法时不能减小范围，间接证明为public  
}

3. 一个普通类实现接口，就必须将该接口的所有抽象方法实现，快捷键：点击要实现接口的名字，按 Alt + Enter ,点击 Implement methods，然后选中要实现的方法。

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

5. 一个类可以同时实现多个接口，中间用逗号隔开。

class Person implements IB,IC {}

6. 接口中的属性，前面默认有 public static final 修饰符，必须初始化。

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

System.out.println(Interface01.n1);

8. 一个接口不能继承其他的类，但是可以继承多个别的接口。

public interface Interface01 extends Interface02,Interface03 {}

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

private interface Interface01{} //报错，修饰符只能是public或默认

10. 用对象名可以调用接口中的属性（另外也可以用类名和接口名调用），但是IDEA没有提示。

public class Test {
    public static void main(String[] args) {
        Teacher a = new Teacher();
        System.out.println(Teacher.n1);
        System.out.println(Interface01.n1);
        System.out.println(a.n1);  //没有报错，证明可以用对象名调用
    }
}

11. 有继承还有接口的类，如果接口和父类某个属性重名，调用时要用接口名和super指定。

public class Teacher extends Person implements Interface01 {
    public void show(){
        System.out.println(Interface01.x);  //输出接口的x
        System.out.println(super.x);        //输出父类的x
        System.out.println(x);  //报错，无法确定哪个x  
    }
}

与继承的比较

当子类继承了父类，就自动的拥有父类的功能（类似父子关系），如果子类需要扩展功能，就可以通过实现接口的方式扩展（类似师徒关系）。比如说金丝猴继承猴子类，拥有了一些猴子的属性，如果金丝猴想要游泳和飞翔，那么就需要实现鱼和鸟的接口。可以理解为：实现接口是对Java单继承机制的一种补充。

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

接口的价值主要在于：设计好各种方法，让其它类去实现这些方法。继承是满足 is - a 关系，而接口只需要满足 like - a 关系即可，接口比继承更加灵活。并且接口在一定程度上实现代码解耦。

接口的多态性

1. 多态参数

Usb接口参数既可以接收手机对象，又可以接收电脑对象，接口引用可以指向实现了接口的类的对象。

public interface Usb {  //接口
    void work();
}

public class Phone implements Usb{
    @Override
    public void work() {
        System.out.println("Usb在手机上工作");
    }
}

public class Computer implements Usb
    @Override
    public void work() {
        System.out.println("Usb在电脑上工作");
    }
}

public class Test {
    public static void main(String[] args) {
        Test a = new Test();
        Phone b = new Phone();
        Computer c = new Computer();
        a.show(b);   //接口的多态，类似向上转型
        a.show(c);
    }
    public void show(Usb a){  //形参是一个接口
        a.work();
    }
}

2. 多态数组

public class Test {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone();
        usbs[1] = new Computer();
        for (int i = 0; i < 2; i++) {
            usbs[i].work();   //调用接口中的方法
            if(usbs[i] instanceof Phone){
                ((Phone) usbs[i]).call();   //类似向下转型,call是Phone类的独特方法
            }
        }
    }
}

由于能调用什么方法是根据编译类型来的，因此想调用call方法需要用到向下转型（类似）。

3. 多态传递现象

interface IA{
    void say();
}
 
interface IB extends IA{  //IB接口继承自IA
    void hi();
}

public class Person implements IB{
     IA a = new Person();   //这里就用到了多态传递现象
     @Override
     public void say() {

     }
     @Override
     public void hi() {

     }    //方法必须全部实现
}

很明显，Person类并没有实现IA接口，但是却可以用IA来实例化对象。原因是Person实现了IB接口，而IB接口继承自IA，Person类把IB和IA接口的方法全部实现，相当于实现了IA。

简而言之，类需要把implements接口的方法，以及接口父类的方法全部实现，然后可以用接口以及接口的子类实例化对象。

内部类（难点、重点）

基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类，嵌套内部类的类称为外部类，是我们类的第五大成员（五大成员：属性、方法、构造器、代码块、内部类）内部类的最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

class Outer{         // 外部类
    class Inner{     // 内部类
    
    }
}

class Other{         // 外部其它类

}

内部类的分类

1. 定义在外部类的局部位置上(方法/代码块内)：A. 局部内部类（有类名） B. 匿名内部类（没有类名，重点）

2. 定义在外部类的成员位置上：A. 成员内部类（没用static修饰）B. 静态内部类（使用static修饰）

局部内部类

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

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

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

4. 外部类访问局部内部类的成员：创建对象再访问（必须在作用域内）。

5. 局部内部类访问外部类成员：直接访问。

public class Outer {
    private int n1 = 10;
    public void say(){
        int n3 = 30;
        class Inner01{
            int n2 = n1;  //直接访问外部类成员
            public void show(){
                System.out.println("调用局部内部类的方法");
            }
        }
        Inner01 a = new Inner01();
        a.show();  //先创建对象再访问局部内部类的成员
    }
    Inner01 b = new Inner01();  //报错，已经不在局部内部类的作用域中了
}

6. 外部其它类不能访问局部内部类（因为局部内部类相当于一个局部变量）。

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

public class Outer {
    private int n1 = 10;
    private static String name = "张三";
    public void say(){
        int n1 = 30;
        class Inner01{
            int n1 = 1000;
            public void show(){
                System.out.println(n1);   //输出 1000，就近原则
                System.out.println(this.n1);  //输出 1000，用this还是就近原则
                System.out.println(Outer.this.n1); //输出 10，外部类定义的变量
                System.out.println(Outer.n1); //报错
            }
        }
        Inner01 a = new Inner01();
        a.show();
    }
}

class Others{
    Inner01 a = new Inner01();  //报错，外部其他类 不能访问 局部内部类
}

匿名内部类

定义在外部类的局部位置，并且没有类名。（1）本质是类（2）该类没有名字（3）同时还是一个对象。

接口：

new 类或接口(参数列表){  //构造器
    类体
}; //注意返回一个指向该类或接口的实例

/* 需求：用IA接口创建对象
   传统方法：写一个类实现该接口，并创建对象。
   但现在的要求是：创建的类只使用一次，后面就不再使用了。
   可以使用 匿名内部类 来简化开发。
*
*/
public class Outer {
    public void create(){   //写在方法内
        IA tiger = new IA(){
            @Override
            public void say() {
                System.out.println("老虎嗷嗷叫");
            }
        };  //匿名内部类，tiger的编译类型为IA，tiger的运行类型就是匿名内部类（也就是 Outer$1）
    }
}

interface IA{
    void say();
}

实际上Jdk底层会给匿名内部类分配一个类名，分配的方法为外部类类名+$（可用tiger的getClass方法查看），然后立即创建一个 Outer$1实例，并且把地址赋给 tiger。

class Outer$1 implements IA {
    @override
    public void cry(){
        System.out.println("老虎嗷嗷叫");  
    }
}

类：

/*
   a的编译类型为 Person1
   a的运行类型为 Outer$1(也就是整个匿名内部类)
   底层会创建一个Person1实例 Outer$1，并返回给a
   class Outer$1 extends Person1{    // 底层创建的类
        @Override
        public void say() {
            System.out.println("在匿名内部类重写父类方法");
        }
   }
   Outer$1 XXX = new Outer$1("Jack");
   Person1 a = XXX;  //XXX被销毁，Outer$1也被销毁
*/

public class Outer {
    public void create(){
        Person1 a = new Person1("Jack") {
            @Override
            public void say() {
                System.out.println("在匿名内部类重写父类方法");
            }
            public void hello(){
                System.out.println("调用匿名内部类独有的方法");
            }  //无法调用，因为编译类型为Person1，不能调用子类独有的方法
        };
        //匿名内部类，不加大括号就是正常的创建类，运行类型为Person1，而加了就是匿名内部类
        a.say();
        System.out.println(a.getClass()); //输出a的运行类型，为 Outer$1
    }
}

class Person1 {
    private String name;
    public Person1(String name) {
        this.name = name;
    }
    public void say(){
    }
}

注意事项

1. 匿名内部类既是一个类的定义，同时它本身也是一个对象（本身就是个返回对象）。因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以直接调用匿名内部类方法。

        new Person1("Jack") {
            @Override
            public void say() {
                System.out.println("在匿名内部类重写父类方法");
            }
        }.say();   //可以new之后直接调用

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

4. 不能添加访问修饰符，因为它的地位就是一个局部变量。

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

6. 匿名内部类访问外部类成员：直接访问。

7. 外部其它类不能访问匿名内部类（因为匿名内部类建立之后就销毁了）。

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

实例

当作实参直接传递，简洁高效。

public class Outer{
    public static void f1(IL il){
        il.show();
    }

    public static void main(String[] args) {
        f1(new IL() {     // 把匿名内部类当作参数导入
            @Override
            public void show() {
                System.out.println("导入匿名内部类");
            }
        });
    }
}

interface IL{
    void show();
}

对比一下传统方法

public class Outer{
    public static void f1(IL il){
        il.show();  
    }

    public static void main(String[] args) {
        Picture a = new Picture();  // 创建一个对象
        f1(a);  // 利用接口的多态
    }
}

interface IL{
    void show();
}

class Picture implements IL{  // 定义一个类实现接口
    @Override
    public void show() {     
        System.out.println("传统方法");
    }
}

成员内部类

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

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

2. 可以添加任意访问修饰符，因为它的地位就是一个成员。

3. 作用域：和外部类的其他成员一样，为整个类。

4. 成员内部类访问外部类成员：直接访问。

5. 外部类访问成员内部类：创建对象再访问。

class Outer{
    private int n1 = 10;
    class inner{
        public void show(){
            System.out.println(n1);  //内部成员类 调用 外部类（私有也可以访问）
        }
    }
    public void say(){
        inner a = new inner();  // 先创建对象                    
        a.show();   // 外部类 调用 内部成员类
    }
}

6. 外部其它类访问成员内部类

第一种方式：把 Inner01 看作 Outer01 的成员，Outer01.Inner01 为编译类型，用外部类实例new

class Others{
    Outer01 outer = new Outer01();
    Outer01.Inner01 inner = outer.new Inner01();  //相当于把 Inner01当作 Outer01的成员
}

第二种方式：在外部类中编写一个方法，可以返回 Inner01 对象

public Inner01 getInner01(){
    Inner01 a = new Inner01();
    return a;
}  //编写方法

class Others{
    Outer01 outer01 = new Outer01();
    Outer01.Inner01 inner01 = outer01.getInner01();  //用对象实例调用方法
}

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

静态内部类

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

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

2. 可以添加任意访问修饰符，因为它的地位就是一个成员。

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

4. 静态内部类访问外部类：直接访问所有静态成员。

5. 外部类访问静态内部类：先在外部类中创建对象再访问。

6. 外部其它类访问静态内部类：

第一种方法：因为是静态内部类，可以通过类名直接访问（满足访问权限）。

    Outer01.Inner01 inner01 = new Outer01.Inner01(); //直接用类名new

第二种方法：编写一个方法，可以返回静态内部类的对象实例。

public Inner01 create(){
    return new Inner01();  //返回一个 静态内部类的实例
} 

class Others{
    Outer01 a = new Outer01();
    Outer01.Inner01 inner01 = a.create();  //调用方法返回实例
}

7. 如果外部类和内部类的成员重名时，内部类访问遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.成员去访问（因为外部类名.this 是对象名，而静态变量可以用类名访问）。

Acc222222

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java的第一遍学习笔记面向对象高级

finalfinal可以修饰类、属性、方法和局部变量。使用1. 当不希望类被继承时，可以用final修饰。2. 当不希望父类的某个方法被子类重写时，可以用final关键字修饰。3. 当不希望类的某个属性的值被修改，可以用final修饰。4. 当不希望某个局部变量被修饰，可以使用final修饰。 public void test(){ final int a = 10; a= 20; //报错 }注意事项1.
复制链接

扫一扫