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 默认初始化值的情况:

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

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

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

1.3方法

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

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

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

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

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.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.5静态

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

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

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

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

• 静态代码块
  类的信息加我完成后，会自动调用静态代码块，可以完成静态属性的初始化功能

class User {
    static {
        System.out.println("这是静态代码块");
    }
    static void test(){
        System.out.println("test");
    }
}

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

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.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.9 final

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

• final以修饰变量：变量的值一旦初始化后无法修改

final String name = "zhangsan";

• final可以修饰属性：那么JVM无法自动进行初始化，需要自己进行初始化（直接赋值初始化或通过构造函数初始化）, 属性值不能发生变化

class User {
	public final String nationality="China";    
	public final String name;
    public User(String name) {
        this.name=name;
    }
}

• 一般将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();

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();

枚举是一个特殊的类，其中包含了一组特定的对象，这些对象不会发生改变, 一般都使用大写的标识符，
枚举使用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);