java语法-面向对象（类与对象、三大特性、关键字使用、特殊类）

1）类与对象

package objectOriented;

import java.lang.reflect.Field;
import java.util.Arrays;

public class ObjectTest {
    public static void main(String[] args) throws Exception {
        // java类的定义和内容
        // 内容：属性、方法、构造器、代码块、内部类

        // ---面向对象
        // 面向过程：函数与数据作为编程操作的单位
        // 面向对象：把函数与数据合为属性和行为一同作为最小操作单位
        // 举例
        

        // ---类与对象 基本使用
        // 类的定义：对象的模板，事物的共用属性方法描述，抽象
        // 对象的定义：对象的实例，对象个体属性方法的实现，具体
        // 定义类 创建对象
        Person p = new Person("hxh",21,'男');
        Person p1 = new Person("zs",18,'男');
        // 属性 方法 访问
        System.out.println( p.name );
        p.name = "hxh";
        p.sayHello();
        // 内存结构：类在方法区内存中，对象引用在栈内存中，对象数据在堆内存中

        // ---属性
        // 成员变量 vs 局部变量
        // 直接在类{}中声明的变量是成员变量
        // 局部变量声明在，代码块内、方法形参、方法内、构造器形参、构造器内
        // 作用域不同：局部变量只在定义的区域中有效，成员变量范围更大
        // 修饰符不同
        
        // 初始化值不同：成员变量有初始化值，局部变量要显式赋值
        // 内存位置不同：成员变量堆空间，局部变量栈空间

        // ---方法
        // 成员方法：可以传递参数，访问成员变量，访问其他方法
        // 方法重载：同名不同参方法
        // 可变形参：可与多个实参匹配的形式参数
        // *方法值传递机制*：本质都是复制栈内存的值，普通类型栈内存值为数据，引用类型栈内存值为堆内存数据地址
        // 递归调用：复杂问题分解，有终结条件，自我调用

        // ---补充
        // 对象数组：数组元素存储对象引用
        // 匿名对象：new对象直接使用，或作为参数传递
        new Person().sayHello();

        // java面向对象三大特性：封装、继承、多态

        // 关键字的使用

    }
}

类的基本设计

package objectOriented;

public class Person {

    // 属性 成员变量
    // 定义： [权限修饰符] [修饰符] 类型 名称 [赋值]
    String name;
    int age;
    char sex;

    // 行为 成员方法
    // 定义： [权限修饰符] [修饰符] 返回值类型 方法名(形参列表)[可能抛出异常]{方法体}
    void sayHello(){
        System.out.println("hello");
    }
    // 方法重载
    void sayHello(String hello){
        System.out.println(hello);
    }
    // 可变形参 不可二义 最多声明一个放在形参最后
    void add(int ...ints){
        // 以数组接收
    }
    void introduceMyself(){
        System.out.println("my name is "+name);
    }
    // 递归方法
    int addfrom1(int i){
        if(i<=0)    return 0;
        if(i==1)    return 1;
        return i+addfrom1(i-1);
    }

    // 构造器 创建对象实例 默认有无参构造器
    public Person(){

    }
    // 实例化 带参数
    public Person(String name, int age, char sex){
        // this代表实例对象
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

2）封装性（包、访问权限、基本构造器与this对象、属性赋值顺序）

package objectOriented;
import java.lang.String;
import static java.lang.Math.PI;

public class Encapsulation {
    public static void main(String[] args) {
        // 封装性
        // 数据和操作数据的行为封装在类内，对外隐藏细节
        // 高内聚低耦合：类内部数据操作细节自己完成，不允许外部干涉，仅暴露少量方法
        // 如：设置Person年龄，限制年龄不能为负数，提供方法设置年龄，进行校验
        // 权限修饰符
        
        // 构造器 创建对象实例 默认有无参构造器 可以有多个构造器重载 定义了构造器将无默认无参构造器
        // 属性赋值顺序：默认值、显式初始化、代码块、构造器赋值、手动赋值
        Encapsulation e = new Encapsulation();
        // Encapsulation e = new Encapsulation(3);
        // e.setI(4);
        System.out.println(e.getI());
        // javaBean：公共类、无参公共构造、私有属性和set get方法
        // this关键字：指当前实例对象，this()调用构造器，this.访问属性方法，
        // this属性无冲突可省略，不复杂的语句不建议省略
        // 构造器只能调用一个，且必须是第一条语句

        // 包 package 访问权限的作用位置
        // 开始行定义 表示类所在的目录结构 限制其他类对此类的访问权限
        // 同包内不可同名类，不同包内可同名类，全类名（包名+类名）保证类名唯一
        // package objectOriented;
        // 导入 import 导入指定包下的类，使用类时就不需要使用全类名
        // import java.lang.String;
        // import java.lang.*;
        String s = "hello";
        // java.lang.String s = new java.lang.String("hello")
        // java.lang.* 默认导入
        // import static 可以导入指定类内静态结构，静态方法或静态量
        double pi = Math.PI;
        // import static java.lang.Math.PI;
        double p = PI;

        // 代码块、内部类 TO LEARN
    }

    // 1
//    private int i = 1;
    // 0
    private int i;

    // 2
//    {
//        i = 2;
//    }

    // 3
    public Encapsulation(int i){
        this.i = i;
    }
    public Encapsulation(){
    }
    // 4
    public void setI(int i){
        this.i = i;
    }
    public int getI(){
        return this.i;
    }
}

3）继承机制（方法重写、this、super）

package objectOriented;

public class Inherit {
    public static void main(String[] args) {
        // 继承性
        // 子类享有父类（基类）结构，使用extends关键字
        // 代码复用，便于扩展
        // 继承获取所有属性和方法
        Son s = new Son();
        s.say();
        // java类只支持单继承，c++支持多继承
        // 所有的类直接或间接继承Object

        // 方法重写：定义方法名和参数列表相同的方法覆盖原方法
        // 1 返回值类型可以是原类型的子类
        // 2 重写方法修饰符>=父类修饰符
        // 3 private修饰的方法不会被覆盖，只有方法存在覆盖，访问父类成员使用super
        // 不会被覆盖的含义是方法中调用了private方法是执行原private方法
        // 覆盖的含义是调用了非private方法执行重写的方法，仍然可以通过super访问原方法
        // private修饰只能在类内部访问，所以父类方法调用private用原方法，而访问不到子类方法
        // 4 子类方法异常<=父类方法异常
        // 5 static类方法没有重写 重写是对象概念

        // super 父类对象 用于访问父类成员
        // super()使用父类构造器创建父类对象，默认构造器第一句
        // 有父类对象才能有子类对象
        // super()调用父类构造器，必须有或默认有
        // this()在构造器内选择用另外的构造器创建实例，
        // 使用了this()第一句就不是super()，但另外的构造器不使用this()那么就是super()
        // 所有构造器最终都直接或间接调用了Object对象的super()
        // 使用成员变量时，先寻找this.变量，未找到，再寻找super.变量
        // 理解
        
    }
}
class Father extends Object{
    private int p = 1;
    public int d = 1;
    public int a = 555;
    public void p(){
        System.out.println(p);
        System.out.println(d);
        this.say();
        this.d();
    }
    private void d(){
        System.out.println("super");
    }
    public void say() {
        System.out.println("hello");
    }

    public Object returnObj(){
        return new Object();
    }

    public Father(int p,int d){
        this.p = p;
        this.d = d;
    }
    public Father(){

    }
}
class Son extends Father{
    // 没有重写一说
    private int p = 6;
    public int d = 7;

    public Son(int p, int d) {
        super(p, d);
        this.p = p;
        this.d = super.d;
    }
    public Son(){
        super();
    }

    public static void main(String[] args) {
//        new Son().p();
        new Son(8,8).p();
    }

    // 注解 修饰作用 编译检查是否重写 可不写
    @Override
    public void p() {
        System.out.println("override");
        d();
    }

    // 不覆盖
    private void d(){
        System.out.println(p);
        System.out.println(d);
        System.out.println(a);
        System.out.println("this");
        System.out.println(this);
    }

    // 覆盖重写
    public void say() {
        System.out.println("world");
        super.say();
    }

    // 返回值类型 子类型
    @Override
    public Integer returnObj(){
        return 1;
    }
}

4）多态性（父子类型转换，虚方法调用）

package objectOriented;

public class Polymorphism {
    public static void main(String[] args) {
        // 多态性
        // 父类引用指向子类对象
        // 以父类模板执行方法，具体执行依据对象方法
        // 编译以父类方法检查，执行以实际对象执行
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.say();
        dog.say();
        // 多态性应用
        Animal animal = new Animal();
        animal.saying( cat );
        animal.saying( dog );
        // 属性没有多态性 是什么类型 重名属性使用对应类型的属性
        // 参数传递匹配参数按照引用类型 如果没有对应类型，则匹配父类接口
        // 如果父类接口重载方法不唯一 则编译错误
        animal.saying( new Cat() );

        // 向下转型 只有对象是该类型或该类型的子类才能转型 可以向父类向上转型
        Cat cat1 = (Cat) cat;
        // 对象类型判断
        System.out.println(cat instanceof Cat);    // true
        System.out.println(cat instanceof Animal); // true
        System.out.println(cat instanceof Object); // true
        System.out.println(cat instanceof Dog);    // false
    }
}
class Animal{
    public void say(){
        System.out.println("animal say");
    }

    // 多态性应用
    public void saying(Animal animal){
        animal.say();
    }
//    public void saying(Cat animal){
//        System.out.println("use cat");
//        animal.say();
//    }
//    public void saying(A a){
//        System.out.println("testA");
//    }
    public void saying(Dog animal){
        System.out.println("use dog");
        animal.say();
    }
}
class Cat extends Animal implements A{
    @Override
    public void say(){
        System.out.println("miao miao miao");
    }
}
class Dog extends Animal{
    @Override
    public void say(){
        System.out.println("wang wang wang");
    }
}
interface A{

}

5）关键字（static、final）

package objectOriented;

public class UseStaticAndFinal {
    // 静态属性 静态变量 类变量
    static int static_i;
    private final int final_i = 1;

    // 静态方法
    public static void doing() {
        System.out.println("static");
    }

    // 静态代码块
    static {
        static_i = 1;
    }

//    {
//        final_i = 1;
//    }

//    public UseStaticAndFinal(int i){
//        final_i = i;
//    }

    public static void main(String[] args) {
        // static 静态的 类的 所有对象的共有特征且完全相同 与类绑定
        // 修饰属性、方法、代码块、内部类
        // 静态属性
        System.out.println(UseStaticAndFinal.static_i);
        // 静态方法
        UseStaticAndFinal.doing();
        // 静态变量 在方法区内存 方法区内存有类的加载信息、静态域、常量池
        // 静态方法 类可以调用，静态方法不能直接调实例方法，不能使用this,super因为没有实例对象
        // 静态变量 全对象共享 静态方法 工具方法，操作静态对象的方法

        // 设计模式之一：单例模式，只有一个对象
        // java实现：私有构造方法，内部创建唯一对象，提供静态方法获取该对象
        System.out.println(
                UseStaticAndFinal.getSingletonInstance()
                ==
                UseStaticAndFinal.getSingletonInstance()
        ); //true

        // 静态方法main入口方法，调用时传递变个数字符串数组
        // 成员变量赋值 代码块和显式赋值顺序依据书写顺序

        // final 修饰 native调用底层代码c或c++
        // 修饰类 不可继承 修饰方法 不可重写
        // 修饰变量 常量 可显式或在代码块或构造器中赋值
        // 修饰局部变量 形式参数或局部变量
    }

    // 饿汉式单例：加载类立即创建
    private UseStaticAndFinal(){
        // 防止反射获取构造器创建对象
        if(o != null){
            return;
        }
    };
    private static Object o = new Object();
    public static Object getSingletonInstance(){
        return o;
    }

    // 懒汉式单例：第一次获取创建实例 synchronized保证多线程不会创建对象冲突
    private static Object b;
    synchronized public static Object getSingletonInstanceLazy(){
        if(b==null) b = new UseStaticAndFinal();
        return b;
    }
}

6）特殊类（Object，包装类）

package objectOriented;

import com.sun.org.apache.xpath.internal.operations.Bool;

import java.util.Vector;

public class SObject {
    public static void main(String[] args) {
        // Object类 所有类的根父类，未继承类的直接父类
        Object o = new Object();
        SObject s = new SObject();
        // 垃圾回收前 调用该方法
        // s.finalize();
        // 对象哈希值
        // s.hashCode();
        Object j = new Object();
        System.out.println( j );
        System.out.println( Integer.toHexString(j.hashCode()) );
        // 对象相等
        // s.equals();
        // 对象拷贝
//        s.clone();
        // 线程相关
//        s.notify();
//        s.wait();
        // 获取类对象 反射相关
//        s.getClass();
        // 对象的字符串表示
        // s.toString();

        // == 和 equals
        // == 基本类型比较值 引用类型比较地址
        // false
        System.out.println(new String("hxh") == new String("hxh"));
        System.out.println("hxh"== new String("hxh"));
        new Object().equals(new Object());  // 底层比较地址
        // true
        System.out.println("hxh"== "hxh"); // 常量池地址相同
        // 底层比较字符数组
        System.out.println( new String("hxh").equals(new String("hxh")) );
        // 重写equals方法 自定义比较规则

        // 默认全类名@虚拟地址(哈希值)
        o.toString();
        System.out.println( o );   // 本质调用对象toString方法
        // 重写toString 获取自定义实体信息

        // 包装类
        // 与基本数据类型对应的引用类型
//        new Byte();
//        new Short();
//        new Integer();
//        new Long();
//        new Character();
//        new Float();
//        new Double();
//        new Boolean();
        // 自动装箱
//        Integer i = new Integer(123);
        Integer i = 1;
        // 自动拆箱
//        int intn = i.intValue();
        int intn = i;

        // 与String类型转换
        String str = String.valueOf( i );
        i = Integer.parseInt( str );

        // 变态题
        Object t = true ? new Integer(1) : new Double(2.0);
        System.out.println( t ); // 1.0
        // 三目运算符统一提升类型 多态调用实际的toString方法

        Integer a = 1;
        Integer b = 1;
        Integer c = 128;
        Integer d = 128;
        Integer e = new Integer(1);
        Integer f = new Integer(1);
        System.out.println(a==b);//true
        System.out.println(c==d);//false
        System.out.println(e==f);//false
        System.out.println(e.equals(f));//true
        e.hashCode();
        e.toString();
        // Integer内部cache数组保存了-128~127的Integer对象

        // 线程安全的动态数组
        new Vector();
    }
}