Java面向对象学习笔记

晓芙蝶

已于 2023-08-18 14:14:47 修改

阅读量57

点赞数

文章标签： java 学习笔记

于 2023-08-15 20:47:58 首次发布

本文链接：https://blog.csdn.net/m0_53267864/article/details/132297313

版权

一、类

1、类的基本内容

//  类的结构:
//  修饰符 class 类名{}
//  注:1、一个.Java文件里只能有一个public修饰的类。
//     2、普通类（外部类）:只能用public、default（不写）、abstract、final作修饰符。
public class Vehicle {

//    类的私有属性:其他类无法直接获取，要通过get方法（看）set方法（改）
//    声明实例变量时，如果没有赋初值，将被初始化为null（引用类型）或者0、false（原始类型）    
    private String brand,color;
    private double speed;

//    类的公有属性:子类可以直接用,直接改
    public double price=100;

//    构造方法的作用是给类初始化
//    如果没有写构方法，Java虚拟机会自动添加一个无参的构造方法，如果写了构造方法Java虚拟机就不会在自动添加构造方法了
//    构造方法不可写返回值类型，因为返回值类型是由java虚拟机决定的，不能在方法中用return语句返回值
//    构造方法只能通过new关键字调用
//    构造方法的结构:
//    类名（参数列表）{}
    Vehicle(String brand,String color)
    {
//        参数列表里的值就是局部变量，局部变量随着栈帧进入栈
//        而对象的属性会随着对象进入堆里面，它俩不在一个地方，所有它俩可以重名
//        this.=指的是当前对象的（this.brand指的是当前对象的私有属性brand)
        this.brand=brand;
        this.color=color;
        speed=0;
    }
//    构造方法可以重载
    Vehicle()
    {

    }
//     get方法
    String getBrand()
    {
        return brand;
    }
    String getColor()
    {
        return color;
    }
    double getSpeed()
    {
        return speed;
    }
//     set方法
    void setColor(String color)
    {
        this.color=color;
    }
//    类的方法
    void run()
    {
        System.out.println("Vehicle内:汽车品牌:"+brand+"颜色:"+color+"汽车速度:"+speed);
    }
}
class VehicleTest
{
    public static void main(String[] args) {
//        创建Vehicle对象
        Vehicle vehicle=new Vehicle("benz","black");
//        调用对象里的方法
        vehicle.run();
        run(vehicle);
    }
//    定义的Vehicle类是一种引用数据类型
    static void run(Vehicle vehicle)
    {
        vehicle.price=500;
        System.out.println("Vehicle外:汽车品牌:"+vehicle.getBrand()+"颜色:"+vehicle.getColor()+"汽车速度:"+vehicle.getSpeed()+" "+vehicle.price);
    }
}

2、内存的类别

栈stack：栈的存取速度比堆快，效率高。在栈内保存基本数据类型的局部变量和对象的引用值。
堆heap：堆可以保存那些对空间要求较大的变量。如对象的属性和数组的元素。在堆内存中开辟空间，只能通过内存分配操作符号new，凡是出现关键字new的地方必定分配了一个堆内存。

3、匿名类

创建了对象但没有变量指向它，它执行完后会被Java垃圾回收机制清理。

new Vehicle("benz","black").run();

4、类的继承

类只能继承一个类。

//继承的关键字extends
class Car extends Vehicle{
    int loader;
    public Car(int loader,String brand,String color)
    {
//        super()的作用是调用父类的构造方法
//        1. 只能出现在子类的构造方法中，且必须是第一行
//        2. super()中的参数，决定了调用父类哪个构造方法
        super(brand,color);
        this.loader=loader;
    }
//    方法的重写
//    1. 相同的方法名
//    2. 相同的参数列表（参数数量、参数类型、参数顺序都要相同）
//    3. 子类的返回值类型必须要小于或者 等于父类的返回值类型。
//    4. 子类的权限修饰符必须要大于或者等于父类的权限修饰符。
    void run(){
        price=1000;
        System.out.println("Vehicle内:汽车品牌:"+getBrand()+"颜色:"+getColor()+"汽车速度:"+getSpeed()+"车载人数"+loader+"  " +price);
    }
}

5、多态

//父类
public class Vehicle {
    private String brand,color;
    private double speed;
    public double price=100;

    Vehicle(String brand,String color)
    {
        this.brand=brand;
        this.color=color;
        speed=0;
    }
    String getBrand()
    {
        return brand;
    }
    String getColor()
    {
        return color;
    }
    void setColor(String color)
    {
        this.color=color;
    }
    double getSpeed()
    {
        return speed;
    }
    void setSpeed(double speed)
    {
        this.speed=speed;
    }
//    类的方法
    void run()
    {
        System.out.println("Vehicle内:汽车品牌:"+brand+"颜色:"+color+"汽车速度:"+speed);
    }
}
//子类
class Car extends Vehicle{
    int loader;
    public Car(int loader,String brand,String color)
    {
        super(brand,color);
        this.loader=loader;
    }
//    方法的重写
    void run(){
        price=1000;
        System.out.println("Vehicle内:汽车品牌:"+getBrand()+"颜色:"+getColor()+"汽车速度:"+getSpeed()+"车载人数"+loader+"  " +price);
    }
}

class VehicleTest
{
    public static void main(String[] args) {
//        下溯造型，即向下转型（Downcasting）称之为强制转换，是将父类对象显式的转换成子类类型。
        Car vehicle1=(Car) new Vehicle("benz","black");
//        上溯造型，即向上转型（Upcasting）是指子类转换为父类，这是自动转换；转换的前提是具有继承或实现关系。
//        多态存在的三个必要条件：
//         1、要有继承，或实现
//         2、要有重写
//         3、父类引用指向子类对象
        Vehicle car=new Car(2,"Honda","red");
//        提高了代码的扩展性
//        run函数在不同类里有不同的表示
//        但调用的还是子类的run函数
        car.run();
        run(car);
    }

//    提高了代码的维护性（ 提高可替换性）
//    子类代码的更改不会影响下面run代码
//    维护时只用去改对应子类即可
    static void run(Vehicle vehicle)
    {
        vehicle.price=500;
        System.out.println("Vehicle外:汽车品牌:"+vehicle.getBrand()+"颜色:"+vehicle.getColor()+"汽车速度:"+vehicle.getSpeed()+" "+vehicle.price);
    }
}

6、instanceof 运算符

1）判断某个对象是不是某个类，返回值布尔类型

对象 instanceof 类

2）判断某个对象是不是某个接口，返回值布尔类型

对象 instanceof 接口

7、final关键字

final是一个关键字，可以修饰程序中的多种元素，包括类、方法、属性和局部变量。

1）使用final修饰的类不能被继承。

2）使用final修饰的方法不能被重写。

3）使用final修饰的变量(属性和局部变量)不能被重新赋值，系统不会对final属性默认的赋初始值，必须要有初始值，并遵守常量命名规范。

8、static关键字

修饰成员变量、成员方法、成员内部类（成员的东西），不可修饰局部内部类，局部变量（局部的东西）。

1）静态变量的特点：

内存中只有一份，无论创建多少对象
类加载时静态变量就进入内存了
静态变量可以改值
不用创建对象，用类名.即可调用

2）静态方法的特点：

类名.即可调用，也可以创建对象调用
类加载的时候静态变量就进入内存了
静态方法内不能用this
静态方法不能调用成员方法和成员属性

9、单例模式：

单例模式（singleton）是保证一个类仅有一个实例，并提供一个访问它的全局访问点，单例模式要点包括：

public class Singleton { 
    //在自己内部定义自己的一个实例，只供内部调用
    private static Singleton instance = new Singleton(); 
    private Singleton(){
    } 

//这里提供了一个供外部访问本class的静态方法，可以直接访问 
public static Singleton getInstance(){ 
	return instance; 
}

10、包

//  package 包名;
package yunque_exercises;
//  import 包名.*;
import java.*;
//  import 包名.子包名.*;
import java.util.*;
//  import 包名.子包名.类名;
import java.util.Scanner;
//  Java类库中常用的包有多个，列举如下几类：
//  java.lang：Java编程语言的基本类库
//  java.awt：提供了创建用户界面以及绘制和管理图形、图像的类
//  javax.swing： 提供了一系列轻量级的用户界面组件，是目前Java用户界面常用的包
//  java.awt.event：图形用户界面事件处理包
//  java.sql：提供了访问和处理来自于Java标准数据源（通常是一个关系型数据库）数据的类
//  java.io：提供了通过数据流、对象序列以及文件系统实现的系统输入、输出
//  java.util：包括集合类、时间处理模式、日期时间工具等各类常用工具包
//  java.net：提供了用于实现网络通讯应用的所有类

//遇到重名的类各用此方法区分开来（包路径不相同）
yunque_exercises.Vehicle vehicle1=new yunque_exercises.Vehicle("benz","black");

二、抽象类

一个类中没有包含足够的信息来描绘一个具体的对象，它只能被继承，派生出子类，这样的类就是抽象类。

1、抽象类不能被实例化；

2、其包含的抽象方法必须在其子类中被实现，否则该子类只能声明为abstract；

3、抽象方法不能为static；

4、抽象类和方法不能被final修饰；

5、其他情况和类相同；

6、在下列情况下，一个类必须声明为抽象类：

当一个类的一个或多个方法是抽象方法时；
当类是一个抽象类的子类，并且没有实现父类的所有抽象方法，即只实现部分；
当一个类实现一个接口，并且不能为全部抽象方法都提供实现时；


[public] abstract class 类名[extends父类][implements接口列表]
{
属性声明及初始化；
抽象方法的声明；
非抽象方法声明及方法体；
}

三、接口

1．修饰接口的修饰符只有public和默认修饰符两种；

2．接口可以是多继承接口；类可以实现多个接口

3.没有构造方法，也不允许被new对象

4．属性必须是public static final（常量，有初值），方法必须是抽象的（无方法体）且为public。

JDK8的接口新特性：

5.接口允许使用静态方法（不能是静态抽象方法）；

6.允许使用defau方法，能写逻辑方法，不要求子类必须重写。

[public] interface 接口名 [extends 父接口列表]{
     // 属性声明
     [public] [static] [final] 属性类型属性名 = 常量值 ;
     // 方法声明
     [public] [abstract] 返回值类型方法名 ( 参数列表 ) ;
}