面向对象

思维导图

一.类的定义

1.类的定义很简单, 就是class + 类名, 如下 , 只是需要注意class前不能 + public , 一个文件中有且只能有一个 public 修饰的类 .

2.定义好一个类之后 我们需要对这个类进行使用, 这时候就需要对类进行实例化, (就是创建该类的对象), 在后续的需求中通过这个对象来调用该类中的方法或者属性. 如下

//类的定义
class Student{
    public String name;
    public int age;
    public String course;

    public void ChoiceCourse(){
        System.out.println("语文");
        System.out.println("数学");
        System.out.println("英语");
    }
}
//类的实例化
Student s = new Student();

类中成员的初始化

1.默认初始化

	   double d;//0
       boolean f;//false
       int c;//0
       String s;//空

2.就地初始化

		School sc = new School();
		 int a = 4;
		String s = "hello";

3.代码块初始化

	{
        System.out.println("BODY");
    }

4.构造方法初始化

public School(){
        System.out.println("school");
        System.out.println(SchoolName);
}

顺序:

就地初始化 = 代码块初始化 > 构造方法初始化

注意:就地初始化和代码块初始化的优先级相同, 根据语句顺序执行

static 关键字

static可以修饰属性, 方法, 类, 还可以修饰代码块, 但修饰不同的东西含义也不同, 最主要的就是修饰属性和方法.

1.修饰属性

一旦一个属性被static所修饰, 那么该属性就从实例属性变成了类属性, 即原来可以通过这个类的对象来调用这个属性, 现在只能通过类名来调用该属性了, 并且这个属性不属于任何一个对象, 而是该类里面的一部分.

public class StudyClass {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.age);
        System.out.println(Student.i);
    }
}
class Student{
    public int age = 20;
    public static int i = 3;
    public void ChoiceCourse(){
        System.out.println("语文");
        System.out.println("数学");
        System.out.println("英语");
    }
}

2.修饰方法

static修饰一个方法后, 该方法也从一个实例方法变成了类方法, 也是通过类名调用该方法. 并且该方法内部不能访问没有加static的属性, 只能访问加了static的属性.

public class StudyClass {
    public static void main(String[] args) {
        Student s = new Student();
        Student.ChoiceCourse();
    }
}
class Student{
    public int age = 20;
    public static int i = 3;

    public static void ChoiceCourse(){
        System.out.println("语文");
        System.out.println("数学");
        System.out.println("英语");
        System.out.println(i);//可以访问
//        System.out.println(age);//无法访问
    }
}

3. 修饰代码块

加上static的代码块, 执行的顺序始终在其他代码块之前, 因为static代码块是在类加载时就执行的, 其他代码块是在创建实例时执行的.

二.继承

1.目的:

继承的存在就是为了使程序员更好的使用重复的代码, 不用通过复制粘贴.

2.基本语法:

class Student extends School {
    public String course;
}

class School{
    public String SchoolName;
    public String SchoolAaddres;

    public static void ChoiceCourse() {
        System.out.println("语文");
        System.out.println("数学");
        System.out.println("英语");
    }
}

这里学生类继承了学校这个类, 就可以拥有School这个类里面的所有属性和方法了.

注意:

~java中一个子类只能有一个父类
~子类会继承父类的所有属性和方法,但带有private的变量和方法在子类中无法被访问
~子类创建的对象中含有父类的对象, 使用super可以得到父类对象的引用.

3 对象在内存中的布局

我们假设子类为A, 继承了B类

final关键字

1.final 修饰一个变量的时候, 表示该变量不能被修改, 即为一个常量.

2.final也可以修饰一个类, 修饰类的时候代表该类不能被继承.

三.组合

组合也是为了代码的重复使用, 但它和继承的区别在与: 
继承是子类和父类之间有从属关系, 例如: 学生类属于学校类
组合是子类和父类之间是拥有关系, 例如: 圆这个类里面有圆心这个类

四.多态

*多态的理解

多态本质上是一种思想, 是将一个引用指向多个实例身上的思想, 这类思想可以帮助我们解决很多平常无法解决的事情,
即可以通过一个引用对应的不同的对象去调用 同一个方法.

1.向上转型

定义: 让父类的引用指向子类的对象;

class Student extends School{
		Student s = new Student();
        School sc = null;
        sc = s;
        
        //另一种写法
        School sc2 = new Student();
}

2.动态绑定

父类中的某个方法在子类中有同名同参数的方法, 就会涉及动态绑定(动态指的是运行时)

此时调用哪个方法取决于当前引用指向父类对象还是子类对象, 指向父类对象则调用父类的方法, 指向子类对象则调用子类方法, 运行时才能判断出来指向哪个对象, 所以是运行时期进行的.

3.方法重写

1.1 重写和重载不同

~重写是子类实现父类的同名同参的方法
~重载是两个方法在同一作用域内, 名字相同, 参数类型或个数不同

1.2 加上static后的方法不能进行重写

1.3重写中子类方法的访问权限必须比父类访问权限大, 不然无法访问

1.4重写的方法返回值最好和父类返回值相同 (特殊情况下可以不相同)

abstract关键字

针对一些没有具体意义, 只是需要被重写的方法, 不需要创建实例的类, 可以加上abstract, 成为一个抽象类.

注意:

1.抽象类不能被实例化, 否则会报错

2.抽象类中也可以有静态成员和其他普通成员

3.抽象类也可以继承别的类, 也可以被别的类继承

4.抽象方法不需要加方法体, 直接加 ; 即可

5.抽象方法只能在抽象类中或接口中存在,

6.抽象方法存在的意义仅仅是为了让子类重写

7.在方法前加上 abstract 就成为了抽象方法

8.抽象方法前不能加 private.否则无法被子类访问就无法重写

9.一个普通的类只能继承一个抽象类

接口

因为一个类可以实现多个接口, 所以 java 通过单继承 + 多接口解决了多继承的问题, 并且刨除了多继承带来的弊端, 因为接口不能被实例化.

注意:

1.接口里的属性默认前面加上了 public static final, 没有普通的属性

2.接口里的方法写不写 abstract 默认都是抽象方法, 且没有普通方法

3.接口也不可以被实例化, 并且里面不能有其他属性

4.接口不能继承类, 只能继承接口

5.接口只能被别的类 ‘实现’ (implements)

6.一个普通的类可以实现多个接口