java面向对象

对象的特点:

1. 对象具有属性和行为
2. 对象具有变化的状态
3. 对象具有唯一性
4. 对象都是某个类别的实列
5. 一切皆为对象，所有事物都可以视为对象 

面向对象的特征：

1. 抽象性：将一类对象的共同特征总结出来构成类的过程。
2. 继承性：子类拥有父类的全部特征和行为，java只支持单继承。
3. 封装性：有选择的隐藏和暴露数据和方法。
4. 多态性：同一类的对象调用相同方法可以表现出不同的行为。

一个类包含以下类型变量

1. 局部变量：在方法和构造方法或者语句块中定义的变量。
2. 成员变量：成员变量定义在内中方法体之外的变量，创建对象时实列化，成员变量可以被类中方法，构造方法或者语句块访问。
3. 类变量：类变量声明在类中，方法体之外，必须声明static类型

 创建类，对象，访问对象

public class Student {   //Student类就是我们自己造的一种引用类型
    //成员变量
    String name;  
    int age;
    String address;
    //方法
    void study(){
        System.out.println(name+"在学习...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

public class StudentTest {
    public static void main(String[] args){
        //创建一个学生对象
        Student zs = new Student();
        //给成员变量赋值
        zs.name = "小周";
        zs.age = 25;
        zs.address = "四川";
        //调用方法
        zs.study();
        zs.sayHi();

        Student ls = new Student();
        ls.name = "小文";
        ls.age = 20;
        ls.address = "四川";
        ls.study();
        ls.sayHi();

        //1)创建了一个学生对象
        //2)给所有成员变量赋默认值
        Student ww = new Student();
        ww.study();
        ww.sayHi();

    }
}

方法的重载(overload/overloading)

在同一类中，方法名相同，参数列表不同

//重载的演示
public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
        o.show(); //编译器根据方法的签名自动绑定方法
        o.show("小智");
        o.show(25);
        o.show("小星",25);
        o.show(25,"小海");
    }
}

class Aoo{
    void show(){}
    void show(String name){}
    void show(int age){}
    void show(String name,int age){}
    void show(int age,String name){}
    //int show(){ return 1;} //编译错误，重载与返回值类型无关
    //void show(String address){} //编译错误，重载与参数名称无关
}

this：

指当前对象，谁调用就指哪个对象，只能在方法中

this.成员变量名

this.方法名（）     调用方法

this()          调用构造方法

class Student {
    String name; //成员变量(整个类中)
    int age;
    String address;
    //局部变量(当前方法中)
    Student(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    void study(){
        System.out.println(name+"在学习...");
    }
    void sayHi(){                       
        System.out.println("大家好，我叫"+name+"，今
                           年"+age+"岁了，家住"+address);
        }
    }

null：表示空，没有指向任何对象

" " :  表示一个没有内容的字符串

构造方法

无参构造

 public show(){
        System.out.println("我是show类的无参构造");
    }

含参构造

写了含参构造会覆盖自动生成的无参构造

public class Student {
    private String name;
    private int age;
//alt + insert选择construct自动生成全参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
//alt + insert选择setandget自动生成
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("小文",23);
        System.out.println(student.getAge());
    }
}

 构造代码块 局部代码块  静态代码块

构造代码块

1. 位置：在类的内部，在方法的外部
2. 作用：用于抽取构造方法中的共性代码
3. 执行时机：每次调用构造方法前都要调用构造代码块
4. 注意事项：构造代码块优先于构造方法加载

局部代码块

1. 位置：在方法的里面的代码块
2. 作用：用于控制变量的作用域
3. 执行时机：每次调用构造方法前都要调用局部代码块
4. 注意事项：作用域越小越好，成员标量存在线程安全 

静态代码块：随着类的加载而加载，并且只加载一次，一般用于项目的初始化

public class boy{
    //1.定义属性
    String name;
    int age;
	static{
		 System.out.println("我是一个静态代码块");
	}
    //2.创建本类的构造代码块
    {
        /*构造代码块：{}
        * 1.位置：类里方法外
        * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
        * 3.作用：用于提取所有构造方法的共性功能*/
        System.out.println("我是一个构造代码块");
        
    }

    //3.创建本类的无参构造
    public boy(){
       System.out.println("我是boy类的无参构造");
    }

    //4.创建本类的含参构造
    public boy(String b){
        //System.out.println("阳光男孩");
        System.out.println("我是boy类的含参构造"+b);
    }

    //5.创建本类的全参构造
    //右键->Generate->Constructor->Shift全选所有属性->ok

    public boy(String name, int age) {
      System.out.println("我是boy类的全参构造");
        this.name = name;
        this.age = age;
    }

    //6.创建普通方法
    public void eat(){
        System.out.println("旋风小蜗牛");
        //7.创建本类的局部代码块
        {
            /*局部代码块：{}
            1.位置：方法里
            2.执行时机：调用本局部代码块所处的方法时才会执行
            3.作用：用于控制变量的作用范围，变量的作用范围越小越好
            * */
            System.out.println("我是一个局部代码块");
            int i = 100;
            System.out.println(i);
        }
        //System.out.println(i);//局部代码块中的局部变量i只能在代码块里使用
    }
}