Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。

类与对象

记录一个基本程序

//定义一个car类
public class Car{
    String mark;
    float price;
    int speed;
    
    public String MakeCar(){
        return this.mark+"汽车,"+"你只要给我"+this.price+"元钱,我就能达到时速"+this.speed;
    }
}

//调用
public class NewCar{
    public static void main(String[] args){
        Car car = new Car();
        car.mark = "宝马";
        car.price = 100000.8f;
        car.speed = 10;
        String mycar = car.MakeCar();
        System.out.println(mycar);
    }
}

对象在内存中的存储

在栈内存中运行的方法,遵循"先进后出,后进先出"的原则。变量p指向堆内存中的空间,寻找方法信息,去执行该方法

封装

Java提供了private, protected, public,default四个访问控制修饰符

  1. 使用 private 关键字来修饰成员变量。
  2. 对需要访问的成员变量,提供对应的一对 getXxx 方法 、 setXxx 方法。

this关键字

this.成员变量名;
this代表所在类的当前对象的引用(地址值),即对象自己的引用。

与PHP中大致相同,由于Java中成员变量的作用范围关系,方法内也可以不用this直接调用变量

构造方法

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

构造方法的写法上,方法名与它所在的类名相同。它没有返回值,所以不需要返回值类型,甚至不需要void。使用构造方法后,代码如下:

package cn.wxuns;

public class Car{
    public String mark;
    public float price;
    public int speed;
    
    //构造方法
    public Car(String mark,float price,int speed){
        this.mark = mark;
        this.price = price;
        this.speed = speed;
    }
    
    public String MakeCar(){
        return this.mark+"汽车,"+"你只要给我"+this.price+"元钱,我就能达到时速"+this.speed;
    }
}

与PHP中的__construct异曲同工

JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类,要求类必须是具体的和公共的,并且具有无参数的构造方法,提供用来操作成员变量的 set 和 get 方法。

public class ClassName{
  //成员变量
  //构造方法
  //无参构造方法【必须】
  //有参构造方法【建议】
  //成员方法   
  //getXxx()
  //setXxx()
}

匿名对象

创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法,但是应用场景非常有限。new完之后直接调用方法或者变量,一个匿名对象,只能使用一次。

new Scanner(System.in).nextInt(); 

Static关键字

静态变量和静态方法

  1. 静态方法可以直接访问类变量和静态方法。
  2. 静态方法 不能直接访问普通成员变量或成员方法。反之,成员方法可以直接访问类变量或静态方法。
  3. 静态方法中,不能使用 this关键字。

static修饰的内容

  1. 是随着类的加载而加载的,且只加载一次。
  2. 存储于一块固定的内存区域(静态区),所以,可以直接被类名调用。
  3. 它优先于对象存在,所以,可以被所有对象共享。

静态代码块

public class ClassName{
  static {
    // 执行语句
  }
}

static 关键字,可以修饰变量、方法和代码块。在使用的过程中,其主要目的还是想在不创建对象的情况
下,去调用方法。

继承

通过 extends 关键字,可以声明一个子类继承另外一个父类

子父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用 super 关键字,修饰父类成员变量,类似于之前学过的 this 。super.父类成员变量名

同名成员变量和同名成员方法会重写父类, super.父类成员方法,表示调用父类的成员方法。

  1. 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。
  2. 子类方法覆盖父类方法,返回值类型、函数名和参数列表都要一模一样。

构造方法

  1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
  2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中,必须先执行父类的初始化动作。子类的构
    造方法中默认有一个 super() ,表示调用父类的构造方法,父类成员变量初始化后,才可以给子类使用。

继承的特点:单继承,多层继承

抽象类

抽象类必须被继承,抽象方法必须被实现

abstract class 类名字 {}
public abstract void 方法名(){}

接口

接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。

 public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

子类实现接口:

  1. 必须重写接口中所有抽象方法。
  2. 继承了接口的默认方法,即可以直接调用,也可以重写。
  3. 静态与.class 文件相关,只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用
  4. 私有方法:只有默认方法可以调用。私有静态方法:默认方法和静态方法可以调用。如果一个接口中有多个默认方法,并且方法中有重复的内容,那么可以抽取出来,封装到私有方法中,供默认方法去调用。从设计的角度讲,私有的方法是对默认方法和静态方法的辅助。
class 类名 implements 接口名 {
    // 重写接口中抽象方法【必须】
   // 重写接口中默认方法【可选】  
}

接口的多实现:

在继承体系中,一个类只能继承一个父类。而对于接口而言,一个类是可以实现多个接口的,这叫做接
口的多实现。并且,一个类能继承一个父类,同时实现多个接口。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
    // 重写接口中抽象方法【必须】
   // 重写接口中默认方法【不重名时可选】  
}
  1. 接口中,有多个抽象方法时,实现类必须重写所有抽象方法。如果抽象方法有重名的,只需要重写一次。
  2. 接口中,有多个默认方法时,实现类都可继承使用。如果默认方法有重名的,必须重写一次。
  3. 接口中,存在同名的静态方法并不会冲突,原因是只能通过各自接口名访问静态方法。
  4. 当一个类,既继承一个父类,又实现若干个接口时,父类中的成员方法与接口中的默认方法重名,子类就近选择执行父类的成员方法。

接口的多继承
一个接口能继承另一个或者多个接口,这和类之间的继承比较相似。接口的继承使用 extends 关键字,子接口继承父接口的方法。如果父接口中的默认方法有重名的,那么子接口需要重写一次。

子接口重写默认方法时,default关键字可以保留。

子类重写默认方法时,default关键字不可以保留.

多态

是指同一行为,具有多个不同表现形式。

  1. 继承或者实现【二选一】
  2. 方法的重写【意义体现:不重写,无意义】
  3. 父类引用指向子类对象【格式体现】
父类类型 变量名 = new 子类对象;
变量名.方法名();

Fu f = new Zi();
f.method();

引用类型转换

向上转型:多态本身是子类类型向父类类型向上转换的过程,这个过程是默认的。编译看左(看父类),运行看右(子类),一定是安全的

父类类型  变量名 = new 子类类型();
如:Animal a = new Cat();

向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

为了避免ClassCastException的发生,Java提供了 instanceof 关键字,给引用变量做类型的校验,格式如下:

a instanceof Cat

final关键字

final : 不可改变。可以用于修饰类、方法和变量。

  1. 类:被修饰的类,不能被继承。
  2. 方法:被修饰的方法,不能被重写。
  3. 变量:被修饰的变量,不能被重新赋值。

内部类

将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。

class 外部类 {
    class 内部类{
    }
}
  1. 内部类可以直接访问外部类的成员,包括私有成员。
  2. 外部类要访问内部类的成员,必须要建立内部类的对象。
外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的 .class文件,但是前面冠以外部类的类名和$符号 。比如,Person$Heart.class

匿名内部类

匿名内部类 :是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
开发中,最常用到的内部类就是匿名内部类了。以接口举例,当你使用一个接口时,似乎得做如下几步操作,

  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法

匿名内部类必须继承一个父类或者实现一个父接口

new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
        // 执行语句
    }
};

Over.