Java面向对象

什么是面向对象

面向过程 & 面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么....
- 面向过程适合处理一些比较简单的问题
面向对象思想
- 物以"类"聚，是分类的思维模式，思考问题时首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思考。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要使用面向过程的思路去处理问题。

什么是面向对象

面向对象编程(Object-Oriented Programming, OOP)。

面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据。
抽象
面向对象的三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的事物，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法的定义和调用

回顾方法

方法的定义
- 修饰符
- 返回值类型
- break：跳出switch，结束循环
- return：结束方法，返回一个结果
- 方法名：首字母小写和驼峰原则，最好见名知意。
- 参数列表：(参数类型参数名)，可变参数...
- 抛出异常：throws
方法的调用
- 静态方法
- 普通方法
- 形参和实参
- 值传递和引用传递
- this关键字

定义方法的格式：

修饰符 返回值类型 方法名(参数列表) {
    //方法体
    return 返回值;
}

类与对象的创建

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 比如：动物、植物、手机、电脑......
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
对象是抽象概念的具体实例
- 小玄子就是人的一个具体实例，小玄子家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建和初始化对象

使用 new关键字创建对象
使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用。
类的构造器也叫做构造方法，是在创建对象的时候必须要调用的。而且构造器有以下两个特点：
- 必须和类名相同
- 一定没有返回类型，也不能写void

构造方法格式：

//无参构造
修饰符 构造方法名() {
  
}

//有参构造
修饰符 构造方法名(参数列表) {
  
}

构造器必须要掌握

程序入口：

package com.oop.demo02;

//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的
        //类实例化后返回一个自己的对象！
        //student对象就是Student类的具体实例！

        // Student student = new Student();
        Student xiaoMing = new Student();
        Student xiaoHong = new Student();

        xiaoMing.name = "小明";
        xiaoMing.age = 10;

        System.out.println(xiaoMing.name);
        System.out.println(xiaoMing.age);

        xiaoHong.name = "小红";
        xiaoHong.age = 10;

        System.out.println(xiaoHong.name);
        System.out.println(xiaoHong.age);
    }
}

Person类：

package com.oop.demo02;

public class Person {

    //一个类即使什么都不写，它也会存在一个构造方法，编译器默认送一个无参构造

    String name;
    int age;
    /*
    构造器：
        1.和类名相同
        2.没有返回值
    构造器的作用
    1.用来初始化值
    2.使用new关键字，本质就是在调用构造器
    注意点：一旦定义了有参构造，必须显式定义一个无参构造
     */
    //显式定义构造器，无参构造
    public Person() {
        this.name = "小玄子"; //初始化值，提前给属性赋值
    }

    //有参构造：一旦定义了有参构造，无参构造就必须显式定义
    public Person(String name) {
        this.name = name;
    }

}

/*
    public class Application {
        public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person(); //调用无参构造，小玄子
        Person person = new Person("弘承"); //调用有参构造，弘承

        System.out.println(person.name);
        }
    }

    构造器：
        1.和类名相同
        2.没有返回值
    作用：
        1.使用new关键字，本质是就在调用构造器
        2.用来初始化值
    注意点：一旦定义了有参构造，必须显式定义一个无参构造
 */

Student类：

package com.oop.demo02;

//学生类
public class Student {
  
    //属性：字段
    String name;
    int age;

    //方法
    public void study() {
        System.out.println(this.name + "在学习");
    }
}

创建对象的内存分析

内存分析

程序入口：

package com.oop.demo03;

public class PetTest {
    public static void main(String[] args) {

        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.bark();

        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
    }
}

Pet类：

package com.oop.demo03;

public class Pet {
    public String name;
    public int age;

    //方法
    public void bark() {
        System.out.println("叫了一声");
    }
}

创建对象的内存分析.png

类与对象小结

类与对象
- 类是一个模板：是抽象
- 对象是一个具体的实例
方法
- 定义、调用！
对象的引用

引用类型，基本类型8种

对象是通过引用来操作的：栈--->堆
属性：也叫字段 Field ，成员变量

默认初始化：

数字：0，0.0

char：u0000

boolean：false

引用：null

格式：修饰符属性类型属性名 = 属性值
对象的创建和使用
- 必须使用 new关键字创建对象，本质就是调用构造器 Person hongcheng = new Person();
- 无参构造
- 有参构造
- 对象的属性 hongcheng.name
- 对象的方法 hongcheng.sleep()
类

静态的属性属性

动态的行为方法

封装（重点）

该露的露，该藏的藏（穿衣😄）
- 我们程序设计要追求 “高内聚，低耦合” 。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉。低耦合就是仅暴露少量的方法给外部使用。
封装（数据隐藏）
- 通常，应该禁止直接访问一个对象的属性，而应该通过操作接口来访问，这叫做数据隐藏。
- 在setter方法中，还可以过滤不合法的数据

总结就是一句话：属性私有，提供 getter/setter方法

封装的作用

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
提高系统可维护性

程序入口：

package com.oop.demo04;

/*
    封装的作用
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.提高系统可维护性
 */

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student();
//        s1.name = "小玄子"; //错误示范
        s1.setName("小玄子"); //封装，通过setter方法给属性赋值
        System.out.println(s1.getName());

//        s1.setAge(500); //不合法！
        s1.setAge(70);//合法
        System.out.println(s1.getAge());
    }
}

package com.oop.demo04;

//类
public class Student {

  	//private：私有的
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供一些可以操作这些私有属性的公有方法！
    //提供一些 public的getter、setter方法

    //getter 获得这个数据
    public String getName() {
        return name;
    }

    //setter 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) { //过滤不合法的数据
            this.age = 0;
            System.out.println("输入的数据不合法");
        } else {
            this.age = age;
        }
    }

}

继承（重点）

继承的本质是对一些类的抽象，从而实现对现实世界更好的建模。
extends的意思是 “扩展“ 。子类是父类的扩展。
Java中的类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个是子类，一个是父类。子类继承父类，使用 extends关键字来表示。
子类和父类之间，从意义上说应该具有 “is a” 关系，如小明是一个人类；旺财是一条狗。
Object类，所有类都继承Object类，是祖宗类。
super - this
方法重写：重点是多态

访问修饰符：

2231755-b495684e9a47678f

程序入口：

package com.oop.demo05;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();

        int money = student.getMoney();
        System.out.println(money);
    }
}

Person类：

package com.oop.demo05;

//在Java中，所有的类都直接或间接继承Object类
//人     父类
public class Person {

    //访问修饰符
    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;

    public void say() {
        System.out.println("父类方法说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

Student类：

package com.oop.demo05;

//学生 is 人   子类
//子类继承了父类，就会拥有父类的全部属性和方法！
public class Student extends Person{
}

super

super注意点：

super 调用父类的构造方法，必须在构造方法的第一行
super 只能出现在子类的方法或构造方法中
super 和 this 不能同时调用构造方法！

this和super区别

代表的对象不同：
- this：代表调用者本身这个对象
- super：代表父类对象的引用
前提
- this：没有继承也可以使用
- super：只能在继承条件下才可以使用
构造方法
- this()：本类的构造方法
- super()：父类的构造方法

程序入口：

package com.oop.demo06;

public class Application {
    public static void main(String[] args) {

       Student student = new Student();
       student.test1();
       student.test2("迪丽热巴");
    }
}

Person类：

package com.oop.demo06;

//在Java中，所有的类都直接或间接继承Object类
//人     父类
public class Person {

    protected String name = "雪王";

    public Person() {
        System.out.println("Person的无参构造执行了");
    }

    //私有的东西无法被继承！
    public void print() {
        System.out.println("执行父类的print方法");
    }

}

Student类：

package com.oop.demo06;

//学生 is 人   子类
//子类继承了父类，就会拥有父类的全部属性和方法！
public class Student extends Person {

    private String name = "古力娜扎";

    public Student() {
        //隐式调用了父类的无参构造，必须在子类构造器的第一行
//        super();
        System.out.println("Student的无参构造执行了");
    }

    //重写父类方法
    public void print() {
        System.out.println("执行子类的print方法");
    }

    public void test1() {
        print(); //执行子类的print方法
        this.print(); //执行子类的print方法
        super.print(); //执行父类的print方法
    }


    public void test2(String name) {
        System.out.println(name); //迪丽热巴
        System.out.println(this.name); //古力娜扎
        System.out.println(super.name); //雪王
    }

}

方法重写

重写的前提条件：需要有继承关系，且是子类重写父类的方法！

方法名、参数列表、返回值类型都必须相同！
修饰符：范围可以扩大，但不能缩小： public>Protected>Default>private
抛出的异常：范围可以缩小，但不能扩大：ClassNotFoundException --> Exception（大）

总结：方法重写，子类的方法和父类必须一致，只有方法体不同！

为什么要重写？

父类的功能，子类不一定需要，或者不能满足子类。

程序入口：

package com.oop.demo07;

public class Application {
    public static void main(String[] args) {

        B b = new B();
        b.test(); //调用了子类B的test方法

        //父类引用指向了子类对象，子类也是父类的衍生，所以可以赋给父类
        A a = new B();
        a.test(); //实际调用了子类B重写的test方法！本来是执行父类test方法，但发现子类重写了这个方法，就转而执行子类方法
    }
}

父类：

package com.oop.demo07;

//重写都是方法的重写，和属性无关
public class A {

    public void test() {
        System.out.println("调用了父类A的test方法");
    }

}

子类：

package com.oop.demo07;

//子类
public class B extends A{

    @Override //注解：有功能的注释！
    public void test() {
        System.out.println("调用了子类B重写的test方法");
    }

}

多态（重点难点）

同一个方法可以根据发送对象的不同而采用多种不同的方法。
一个对象的实际类型是确定的，但指向对象的引用类型有很多。
多态的前提条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
多态的注意点：

多态是方法的多态，属性没有多态
instanceof，用于引用类型的转换，判断一个对象是什么类型。
父类和子类，有联系类型转换异常！ ClassCastException
多态前提条件：继承关系，方法需要重写，父类引用指向子类对象！Father f = new Son();
static 方法，也叫静态方法，属于类，它不属于实例！
final 常量
private 方法

程序入口：

package com.oop.demo08;

public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //Person person = new Person();
        //Student student = new Student();

        //可以指向的引用类型就不确定了：父类引用指向子类对象，是多态
      	//Person p = new Student();

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 可以指向子类对象，但不能调用子类私有(独有)的方法！
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边变量关系不大！
        s2.run(); //实际调用了子类重写的run方法！本来是执行父类run方法，但发现子类重写了这个方法，就转而执行子类方法
//        s2.eat(); //不能调用子类私有的方法
//        s3.run();
        s1.eat();
    }
}

父类：

package com.oop.demo08;

public class Person {

    public void run() {
        System.out.println("Person");
    }

}

子类：

package com.oop.demo08;

public class Student extends Person{

    //重写父类方法
    @Override
    public void run() {
        System.out.println("son");
    }

    //子类私有方法
    public void eat() {
        System.out.println("eat");
    }
}

instanceof和类型转换

instanceof

instanceof 比较两个对象类型是否相等，如果相等返回true，如果不等返回false。

instanceof 格式：

boolean flag1 = object instanceof Person;
boolean flag2 = Person instanceof Student;

类型转换

父类引用指向子类对象，是多态
把子类转换成父类，是向上转型
把父类转换成子类，是向下转型：需要强制类型转换
类型转换，方便了方法调用，减少重复代码

类型转换语法：

//向下转型，父类-->子类，就可以使用子类的方法
Person student = new Student(); //父类引用指向子类对象
Student student1 = (Student) student; //强制类型转换

//向上转型，子类-->父类，可能会丢失自己的方法
Student student2 = new Student();
Person student2p = student2;

程序入口：

package com.oop.demo09;

public class Application {
    public static void main(String[] args) {

        //Object > String           可见
        //Object > Person > Teacher 可见
        //Object > Person > Student 可见
        Object object = new Student();
        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //false，因为Student不是Teacher
        System.out.println(object instanceof String); //false，因为Student不是String
        System.out.println("--------");

      	//Object > String           不可见
        //Object > Person > Teacher 可见
        //Object > Person > Student 可见
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Teacher); //false
        //System.out.println(person instanceof String); //编译报错，不可见
        System.out.println("--------");

      	//Object > String           不可见
        //Object > Person > Teacher 不可见
        //Object > Person > Student 可见
        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person); //true
        System.out.println(student instanceof Object); //true
        //System.out.println(student instanceof Teacher); //编译报错，不可见
        //System.out.println(student instanceof String); //编译报错

        //类型之间的转换： 父      子
        //高                     低
        Person student1 = new Student();

        //把这个对象转换成Student类型，我们就可以使用Student类型的私有方法了
//        student1.go(); //Person类没有go()方法
        Student student1s = (Student) student1;
        student1s.go();
        ((Student) student1).go(); //匿名，可读性差

        //子类转换为父类，可能会丢失自己的一些方法
        Student student2 = new Student();
        student2.go();
        Person person1 = student2;
        //person1.go(); //不可以调用子类私有的方法

    }
}

父类：

package com.oop.demo09;

public class Person {
}

子类：

package com.oop.demo09;

public class Student extends Person{

    public void go() {
        System.out.println("go");
    }
}

子类：

package com.oop.demo09;

public class Teacher extends Person{
}

static【重点】

static静态导包

静态包与类一同加载。
使用静态导包，可以不用写 类名.方法名() 调用静态方法，而直接用 方法名() 就可以调用静态方法。实际工作中，推荐使用 类名.方法名()，可读性更好

语法：

import static 包名.类名.方法名

package com.oop.demo10;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    
    public static void main(String[] args) {
//        System.out.println(Math.random()); //类名.方法名
        System.out.println(random()); //方法名
        System.out.println(PI); //常量
    }
}

static与代码块【重点】

有匿名代码块和静态代码块。
静态代码块先执行，因为它与类一起加载，但是它只执行一次。
匿名代码块后执行，但也比构造器先执行，它可以执行多次。
优先级：静态代码块-->匿名代码块-->构造方法

package com.oop.demo10;

public class Person {
  
    //2：匿名代码块可以执行多次
    {
        System.out.println("匿名代码块");
    }

    //1：静态代码块只执行一次
    static {
        System.out.println("静态代码块");
    }

    //3：构造方法
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("-----------");
        Person person2 = new Person();
    }
}

静态变量和静态方法【重点】

静态变量

调用静态变量使用 类名.变量名 ，静态变量与类一起加载，只执行一次，整个类共享一个静态变量。

普通变量

调用非静态变量使用 对象名.变量名，普通变量在对象被创建时诞生，当对象被回收时，普通变量也会被销毁，每创建一个对象普通变量都会被重新创建并初始化。

静态方法

静态方法不能调用非静态方法，因为创建静态方法时，普通方法还没有！

普通方法

普通方法可以调用静态方法。因为创建普通方法时，静态方法已经有了

package com.oop.demo10;

public class Student {

    private static int age; //静态变量
    private double score; //非静态变量，普通变量

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age); //推荐，使用静态变量 类名.变量名
        System.out.println(s1.age); //不推荐
        System.out.println(s1.score); //使用普通变量，对象.变量名

        Student s2 = new Student();
        s2.run();
    }

  	//普通方法
    public void run() {
        go(); //普通方法调用静态方法
    }

  	//静态方法
    public static void go() {
				System.out.println("这是静态方法");
    }
}

抽象类（重点难点）

使用 abstract 修饰符可以修饰方法也可以修饰类，如果修饰方法，那么这个方法就是抽象方法，如果修饰类，那么这个类就是抽象类。
抽象类可以没有抽象方法，但是有抽象方法的类一定是抽象类。

特点：

抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，就必须实现抽象类没有实现的抽象方法，否则这个子类也要声明为抽象类。

思考：抽象类有构造器吗？

不能new对象，说明没有构造器

抽象类存在的意义：把公有特征抽象出来，提高开发效率！

程序入口：

package com.oop.demo11;

public class Application {
    public static void main(String[] args) {

//        Action action = new Action(); //抽象类无法new对象
    }
}

抽象类：

package com.oop.demo11;

//abstract 抽象类
public abstract class Action {

    //abstract，抽象方法，只有方法名，没有方法实现！
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它！
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象类是抽象的抽象

    //思考：抽象类有构造器吗？
    //不能new对象，说明没有构造器
    //抽象类存在的意义：把公有特征抽象出来，提高开发效率
}

子类：

package com.oop.demo11;

//抽象类的所有方法，继承它的子类都必须要实现它的抽象方法。如果子类不能实现父类的所有抽象方法，那么子类也要声明成抽象类
public class A extends Action{
    @Override
    public void doSomething() {
				System.out.println("子类重写了父类的抽象方法");
    }
}

接口的定义与实现（重点难点）

接口

普通类：只有具体实现，也就是只有普通方法
抽象类：具体实现和抽象方法都有！也就是有抽象方法和普通方法
接口：只有抽象方法！自己无法写方法（方法实现），规范和实现分离：面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界中”如果你是...就必须能...“ 的思想。如果你是天使，就必须能飞。如果你是汽车，就必须能跑。如果你是好人，就必须干掉坏人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家一起遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是 class，声明接口的关键字是 interface

接口的作用

约束，抽象
定义一些方法框架，让不同的人实现
（public abstract），默认的不写也有，接口中的方法是抽象方法
（public static final），默认的不写也有，接口中的属性是静态常量
接口不能被实例化，即不能new接口，因此接口中没有构造方法！
implements 可以实现多个接口
实现接口时必须要重写接口中的方法

实现接口

类可以实现接口，使用 implements关键字实现接口，实现接口的类，需要重写接口中的方法。
接口的属性都是静态常量 public static final，不写 public static final，编译器也默认给
接口中所有定义的方法其实都是抽象方法 public abstract，不写 public abstract，编译器也默认给

Java是单继承的，但可以使用接口做到多实现。

格式：

public class ClassName implements interface1, interface2 {}

实现类：

package com.oop.demo12;

//抽象类：extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的所有方法

//多继承，利用接口实现多继承，这里实现了2个接口
public class UerServiceImpl implements UserService, TimeService {
  
  	//重写接口的所有方法
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口：⚠️

package com.oop.demo12;

//interface 是定义接口的关键字，接口都需要有实现类
public interface UserService {

    //接口的属性都是静态常量 public static final
    int AGE = 99; //看起来像变量，实际上是静态常量

    //接口中的所有定义的方法其实都是抽象方法 public abstract，没有具体实现
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

接口：

package com.oop.demo12;

public interface TimeService {
    void timer();
}

接口也是一个类，叫接口类。接口也可以创建对象实例。

1.UserService接口

interface UserService {
    void hello();
}

public class UserServiceTest {
    public static void main(String[] args) {

      	//接口也可以创建对象实例
        UserService userService = new UserService() {

            @Override
            public void hello() {
                System.out.println("hello");
            }
        };
        userService.hello();

    }
}

内部类（重点难点）

内部类就是在一个类的内部再定义一个类。比如：A类中定义了一个B类，那么B类相对A类来说就叫做内部类，而A类相对B类来说就是外部类。

1、成员内部类，它定义在一个类的内部，成员内部类可以访问外部类的所有成员属性和成员方法。

2、静态内部类，和成员内部类很像，就多了一个 static关键字修饰。

3、局部内部类，也叫方法内部类，它定义在一个方法内或者一个作用域里面的类。

4、匿名内部类，没有名字的类。

注意⚠️：一个源代码文件中可以有多个class类，但是只能有一个 public class！

程序入口：

package com.oop.demo13;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inter inter = outer.new Inter();
        inter.in();
    }
}

内部类：

package com.oop.demo13;

public class Outer {

    private int id = 5;
    public void out() {
        System.out.println("这是外部类的方法");
    }

    //成员内部类
    class Inter {
        public void in() {
            System.out.println("这是成员内部类方法");
            System.out.println(id); //成员内部类可以访问外部类的所有成员属性和成员方法
        }
    }

    //静态内部类
    public static class Static {
        public void in() {
            System.out.println("这是静态内部类的方法");
        }

        //获得外部类的私有属性！
        public void getID() {
//            System.out.println(id);
        }
    }

    //局部内部类，在方法里定义一个类
    public void method() {

        class Inter {
            public void in() {
                System.out.println("这是局部内部类的方法");
            }
        }
      
    }

}

//一个源代码文件中可以有多个class类，但是只能有一个public class
class A {

}

class B {

}

posted @ 2021-07-31 00:04 siming笨笨阅读(100) 评论(0) 收藏举报

刷新页面返回顶部

siming笨笨

Java面向对象

什么是面向对象

面向过程 & 面向对象

什么是面向对象

回顾方法的定义和调用

回顾方法

类与对象的创建

类与对象的关系

创建和初始化对象

创建对象的内存分析

内存分析

类与对象小结

封装（重点）

继承（重点）

super

方法重写

多态（重点难点）

instanceof和类型转换

instanceof

类型转换

static【重点】

static静态导包

static与代码块【重点】

静态变量和静态方法【重点】

抽象类（重点难点）

接口的定义与实现（重点难点）

接口

接口的作用

实现接口

内部类（重点难点）

公告