• Java面向对象---尚硅谷Java入门视频学习

    1.类和对象

    1.1创建过程

    对象是将内存地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量，而变量的类型（即类）称之为引用数据类型。
    在这里插入图片描述

    • 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
    • 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference 类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。

    特殊的对象：空对象（null），没有引用的对象，称孩子为空对象，关键字对象。
    所有引用类型变量的默认值就是null。

    1.2 属性

    属性即类的对象的相同特征
    声明：属性类型 属性名称=属性值
    如果在声明属性的同时进行了初始化赋值，那么所有对象的属性就完全相同，所以如果希望每个对象的属性不一致，那么可以不用在声明属性的时候进行初始化。
    类的属性，根据其类型，都有默认初始化值。默认初始化值的情况：

    • 整型(byte、short、int、long):0

    • 浮点型(float、double)：0.0

    • 字符型（char）：0（或’\ue000’）

    • 布尔型（boolean)：false

    • 引用数据类型（类、数组、接口）:null

    属性(成员变量) vs 局部变量
    1.相同点:

    • 1.1 定义变量的格式:数据类型 变量名 = 变量值

    • 1.2 先声明，后使用

    • 1.3 变量都有其对应的作用域
      2.不同点:

    • 2.1 在类中声明的位置不同
      属性:直接定义在类的一对{}内
      局部变量:声明在方法内、方法形参、构造器形参、构造器内部的变量

    • 2.2 关于权限修饰符的不同
      属性:可以在声明属性时，指明其权限，使用权限修饰符。
      常用的权限修饰符:private、public、缺省、protected
      目前声明属性时，都使用缺省即可。
      局部变量:不可以使用权限修饰符。

    • 2.3 默认初始化值的情况:

       属性:类的属性，根据其类型，都有默认初始化值。
 局部变量:没有默认初始化值
 	意味着:在调用局部变量之前，一定要显式赋值，否则会出错。
 	特别地:形参在调用时,赋值即可。

      • 1
      • 2
      • 3
      • 4

    • 2.4 在内存中加载的位置，亦各不相同。

       属性:加载到堆空间中(非 static)
 局部变量:加载到栈空间

      • 1
      • 2

    1.3方法

    当参数的个数不确定，但是类型相同时，可以采用特殊的参数语法声明：可变参
    语法：参数类型.…参数名称

    class User{
	void test(String ...name){
		System.out.println(name[0]); //数组
	}
}
//调用
User user =new User();
user.test("zhangsan","lisi");  //zhangsan

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    如果参数种还包含其他含义的参数，那么可变参数应该声明再最后。

    class User{
	void test(int age,String ...name){
		System.out.println(age+"  "+name[0]);
	}
}
//调用
User user =new User();
user.test(10,"zhangsan","lisi");  //10  zhangsan


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    public class test1 {
    public static void main(String[] args) {
        // 1.传空参数
        System.out.println(add()); 
        // 2.传多个值
        System.out.println(add(1, 2, 3, 4));
        // 3.传单个值
        System.out.println(add(1));
        // 4.传数组
        System.out.println(add(new int[]{1, 4, 5, 6}));
    }
    public static int add(int... nums){
        // 在方法内部，nums实际为一个数组
        System.out.println("数据长度："+ nums.length);
        int ans = 0;
        for (int num : nums) {
            ans += num;
        }
        return ans;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述

    1.4多态

    所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态

    • 多态语法其实就是对对象的使用场景进行了约束
    • 一个对象可以使用的功能取决于引用变量的类型
    public class Main{
    public static void main(String[] args) {
        Person p = new Person();
        p.testPerson();
        Person p1 = new Boy();
        p1.testPerson();  //输出 test person...
        //p1.testBoy();  //无法执行
        Person p2 = new Girl();
        p2.testPerson();
        //p2.testGirl();

        Boy boy = new Boy();
        boy.testBoy();

        Girl girl = new Girl();
        girl.testGirl();
    }
}

class Person {
    void testPerson() {
        System.out.println("test person...");
    }
}
class Boy extends Person {

    void testBoy() {
        System.out.println("test boy...");
    }
}
class Girl extends Person {

    void testGirl() {
        System.out.println("test girl...");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    1.5静态

    针对于具体对象的属性称之为对象属性，成员属性，实例属性
    针对于具体对象的方法称之为对象方法，成员方法，实例方法
    把和对象无关，只和类相关的称之为静态，在属性或者方法前加static关键字定义
    和类相关的属性称之为静态属性
    和类相关的方法称之为静态方法
    使用类名.静态方法名（属性名）直接调用

    class Bird {
    static String type = "鸟";
    static void fly() {
        System.out.println("飞...");
    }
}

Bird.fly();
 System.out.println(Bird.type);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    先有类，后有对象。
    成员方法可以访问静态属性和静态方法；（对象存在，类必定存在）
    静态方法不能访问成员方法

    • 静态代码块
      类的信息加我完成后，会自动调用静态代码块，可以完成静态属性的初始化功能
    class User {
    static {
        System.out.println("这是静态代码块");
    }
    static void test(){
        System.out.println("test");
    }
}

//调用
User.test();
//输出
这是静态代码块
test

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1.6 访问权限

    Java的源码中，公共类（public）只能有一个，而且必须和源码文件名相同
    main方法：main方法是由JVM调用的，JVM调用时应该可以任意调用，而不用考虑权限问题。
    Java中的访问权限主要分为么种：

    • 1.private：私有的，同一个类中可以使用

    • 2.（default）：默认权限，当不设定任何权限时，JVM会默认提供权限，包（路径）权限，相同包路径才可使用

    • 3.protected：受保护的权限，相同包路径，子类可以访问

    • 4.pubtic：公共的，任意使用

    1.7内部类

    外部类，就是在源码中直接声明的类，Java不允许外部类处用private，protected修饰
    内部类，就是类中声明的类，内部类就当成外部类的属性使用即可

    
public class Main{
    public static void main(String[] args) {
        // 因为内部类可以看作外部类的属性，所以需要构建外部类对象才可以使用
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass innerClass = outer.new InnerClass();
    }
}
class OuterClass {
    public class InnerClass {

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    1.8 单例模式

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

        // TODO 面向对象 - 单例模式
        // JVM默认给类提供的构造方法，其实就是公共的，无参的构造方法
        // 1. 类的创建过程复杂
        // 2. 类的对象消耗资源
        //User user = new User();
        User instance1 = User.getInstance();
        User instance2 = User.getInstance();
        User instance3 = User.getInstance();
        User instance4 = User.getInstance();
        User instance5 = User.getInstance();
        User instance6 = User.getInstance();
		//不管调用多少次，仍然是同一个对象
        System.out.println(instance1.equals(instance6));

    }

}
class User {
    private static User user = null;

    private User() {

    }
    public static User getInstance() {
        if ( user == null ) {
            user = new User();
        }
        return user;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    1.9 final

    Java中提供了一种语法，可以在数据初始化后不被修改,使用关键字final

    • final以修饰变量：变量的值一旦初始化后无法修改
    final String name = "zhangsan";

    • 1
    • final可以修饰属性：那么JVM无法自动进行初始化，需要自己进行初始化（直接赋值初始化或通过构造函数初始化）, 属性值不能发生变化
    class User {
	public final String nationality="China";    
	public final String name;
    public User(String name) {
        this.name=name;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 一般将final修饰的变量称之为常量，或者叫不可变变量
    • final可以修饰方法，这个方法不能被子类重写
    • final可以修饰类，这样类就没有子类了
    • final不可以修饰构造方法
    • final可以修改方法的参数，一旦修饰，参数就无法修改。

    1.10 抽象

    分析问题：对象（具体） => 类（抽象）
    编写代码：类（抽象） => 对象（具体）

    • 抽象类 : 不完整的类，就是抽象类（类中有抽象方法，则该类需被声明为抽象类）
      abstract class 类名
    • 抽象方法 ： 只有声明，没有实现的方法
      abstract 返回值类型 方法名（参数）
    • 如果一个类中含有抽象方法，那么这个类是抽象类；反之不成立，类为抽象类，其中的方法不一定为抽象方法。

    因为类不完整，所以无法直接构造对象，无法实例化，但是可以通过子类间接构建对象
    如果抽象类中含有抽象方法，那么子类继承抽象类，需要重写抽象方法，将方法补充完整

    abstract class Person {
    public abstract void eat();
    public void test() {

    }
}
class Chinese21 extends Person {
    public void eat() {
        System.out.println("中国人使用筷子吃饭");
    }
}

Chinese21 c = new Chinese21();
 c.eat();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    abstract关键字不能和final同时使用

    1.11 接口和枚举

    所谓的接口，可以简单理解为规则
    基本语法 ： interface 接口名称 { 规则属性，规则的行为 }
    接口其实是抽象的
    规则的属性必须为固定值，而且不能修改。
    属性和行为的访问权限必须为公共的。
    属性应该是静态的
    行为应该是抽象的
    接口和类是两个层面的东西
    接口可以继承其他接口
    类的对象需要遵循接口，在java中，这个遵循，称之为实现(implements)，类需要实现接口,而且可以实现多个接口

    interface USBInterface {

}
interface USBSupply extends USBInterface {
    public void powerSupply();
}
interface USBReceive extends USBInterface {
    public void powerReceive();
}
class Computer implements USBSupply {

    public USBReceive usb1;
    public USBReceive usb2;

    public void powerSupply() {
        System.out.println("电脑提供能源");
        usb1.powerReceive();
        usb2.powerReceive();
    }
}
class Light implements USBReceive {
    public void powerReceive() {
        System.out.println("电灯接收能源");
    }
}

Computer c = new Computer();
Light light = new Light();
c.usb1 = light;
Light light1 = new Light();
c.usb2 = light1;
c.powerSupply();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    枚举是一个特殊的类，其中包含了一组特定的对象，这些对象不会发生改变, 一般都使用大写的标识符，
    枚举使用enum关键字使用

    class MyCity {
    public String name;
    public int code;
    private MyCity(String name, int code) {
        this.code = code;
        this.name = name;
    }

    public static final MyCity BEIJING = new MyCity("北京", 1001);
    public static final MyCity SHANGHAI = new MyCity("上海", 1002);
}
enum City {
	//枚举类不能创建对象，它的对象是在内部自行创建   
	//等同于创建对象
    BEIJING("北京", 1001), SHANGHAI("上海", 1002);  //枚举类会将对象放置在最前面，那么和后面的语法需要使用分号隔开
    City( String name, int code ) {
        this.code = code;
        this.name = name;
    }
    public String name;
    public int code;
}

System.out.println(City.BEIJING.name);
System.out.println(City.SHANGHAI.code);
System.out.println(MyCity.SHANGHAI.name);
System.out.println(MyCity.BEIJING.code);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
  • 相关阅读:
    【推理引擎】如何在 ONNXRuntime 中添加新的算子
    C++：vector容器是否包含给定元素
    从零开始搭建仿抖音短视频APP-后端开发消息业务模块（1）
    c++ 输出格式的变化示例
    ORA-01005 vs ORA-28040
    【C++】右值引用
    用栈实现队列、用队列实现栈(C语言_leetcode_232+225)
    1.NC4 判断链表中是否有环
    LC-2300. 咒语和药水的成功对数（排序+贪心、排序+二分）
    【软件测试】7年资深带你详探什么是测试开发？
  • 原文地址：https://blog.csdn.net/Monstar_ViCtory/article/details/127872250