面向对象，构造方法，this，构造代码块，匿名对象，成员变量和局部变量

 面向对象引入

　　面向对象是一种编程范式（一种套路---为一类问题提供了统一的解决方案）

　　面向过程关注的是代码实现的细节：（买菜，洗菜，烧菜）

　　缺陷：代码实现细节，复用性低

　　面向对象：先将代码实现的细节整合到对象中，只要我们能拿到对象，就能拿到对象身上的所有功能（对象：厨师（买菜，洗菜，烧菜））

　　面向对象是基于面向过程的

　　面向对象不一定优于面向过程：如果场景较简单，优先选择面向过程，如果场景较复杂优先选择面向对象

 

类与对象的关系

　　对这一类对象进行抽取，共同特征抽取成了属性，共同行为抽取成了方法，这一类对象抽取成了一个类----类是对象的概括

　　对象是类的实现

public class Test2 {
    public static void main(String[] args) {
        //创造实例（对象--p），并且调用构造方法；
        Person p = new Person();
        p.name="ad";
        p.eat();
​
    
        Person p1 = new Person();
        p1.name = "ls";
        p1.eat();
    }
}
​
class Person{
    //属性
    String name;
    int age;
    char gender;
    
    //方法
    public void eat(){
        System.out.println(name+"在吃饭");
    }
    public void sleep(){
        System.out.println(name+"在睡觉");
    }
}
​

 

cn.tedu.test.Person	@	2a139a55
在cn.tedu.test.Person类中创建的对象	后面是地址	内存地址

 

参数类型是引用类型，只能传对象，因为对象才有地址值

public class Test2 {
    public static void main(String[] args) {
        //创造实例
        Person p = new Person();
        p.name="小红";
        m(p);                       //2.--------传输对象
        p.eat();
    }
    
    public static void m(Person p){     //1.-------参数类型是引用类型，只能传对象，因为对象才有地址值
        p.age=20;
    }
}
​
class Person{
    //属性
    String name;
    int age;
    char gender;
    
    //方法
    public void eat(){
        System.out.println("他叫："+name+"今年"+age+"岁"+"在吃饭");
    }
}

 

构造方法

　　构造方法没有返回值类型，与类同名

　　构造方法用于创建对象

　　如果类中没有定义构造方法，JVM默认添加一个无参构造方法

public class Test2 {
    public static void main(String[] args) {
        //创造实例
        Person p = new Person("张三");
        m(p);
        p.eat();
        
    }
    
    public static void m(Person p){
        p.age=20;
    }
}
​
class Person{
    //属性
    String name;
    int age;
    char gender;
    
    //如果类中没有定义构造方法，JVM会在底层默认添加一个无参构造
    //构造方法没有返回值类型，与类同名
    //构造方法支持重载
    public Person(){}   //---------------  默认构造方法（无参，无返回值）
    
    public Person(String name){
        name =name;
    }
    //方法
    public void eat(){
        System.out.println("他叫："+name+"今年"+age+"岁"+"在吃饭");
    }
    
}

 

JAVA 的就近原则：this-----------当前类的对象

　　在java中所有的非静态属性和方法都可以通过对象调用

　　在java中所有的非静态属性和方法都可以通过对象调用

public class Test2 {
    public static void main(String[] args) {
        //创造实例
        Person p = new Person("张三");
        m(p);
        p.eat();
        
    }
    
    public static void m(Person p){
        p.age=20;
    }
}
​
class Person{
    //属性
    String name;
    int age;
    char gender;
    
    public Person(String name){    
        name =name; //-----------Java有就近原则，应该改为this.name =name;
    }
    //方法
    public void eat(){
        System.out.println("他叫"+name+"今年"+age+"岁,"+"在吃饭");
    }
    
}

 

this

　　this(是一个地址值)：当前类的对象，可以指带没有创建的对象，可以指带刚创建的对象，还指代正在使用的对象，是一个灵活的指代（正在活动的对象）

public class Test2 {
    public static void main(String[] args) {
        //创造实例
        Student s1 = new Student();
        
        System.out.println(s1); //---与下方地址值一样
        
        Student s2 = new Student();
    
        System.out.println(s2); //---与下方地址值一样
    }
    
}
​
class Student{
    //属性
    String name;
    int age;
    char gender;
    public Student(){
        System.out.println(this);   //---this指代刚创建出来的对象
    }
}

 

this()语句：

　　只能出现在首行

　　在本类中的构造方法调用其他形式的构造方法

public class Test2 {
    public static void main(String[] args) {
        
    }
}
​
class Student{
    //属性
    String name;
    int age;
    char gender;
    public Student(){
        System.out.println(this);
    }
    
    public Student(String name){
        this.name=name;
    }
    
    public Student(String name,int age){
        this(name);                 //-----------调用有参构造方法
        this.age=age;
    }
    
    public void Study(){
        System.out.println(this.name+"在学习");
    }
}

 

构造代码块

　　在方法外，类内出现 { }，则为构造代码块，所有的构造方法先执行 构造代码块内容，

public class Test2 {
    public static void main(String[] args) {
        Baby b = new Baby();
        b.eat();
    }
}
​
class Baby{
    
    //属性
    String name;
    int age;
    char gender;
​
    //构造代码块-----所有的构造方法先执行
    //底层会将这段代码放进所有的构造方法中
    {
        this.name = "lili";
        this.age = 1;
    }
    
    public Baby(){
        
    }
    
    public Baby(String name){
    
    }
    public Baby(int age,String name){
        
    }
    //方法
    public void eat(){
        System.out.println(this.name+"吃奶");
    }
}

 

匿名对象

　　没有名字的对象，当作参数传递的时候，可以使用匿名对象

public class Test2 {
    public static void main(String[] args) {
        //匿名对象
        new Baby();
        new Baby().eat();
        
        m(new Baby());
    }
    public static void m(Baby b){
        
    }
}
​
class Baby{
    
    //属性
    String name;
    int age;
    char gender;
​
    //构造代码块-----所有的构造方法先执行
    //所有构造方法必走
    {
        this.name = "lili";
        this.age = 1;
    }
    public Baby(){
        
    }
    
    public Baby(String name){
    
    }
    public Baby(int age,String name){
        
    }
    //方法
    public void eat(){
        System.out.println(this.name+"吃奶");
    }
    
}

 

 

方法代码块（局部代码块）控制变量的生命周期

　　在方法中出现 { } 用于控制变量的生命周期，提高内存利用率

public class Test2 {
    public static void main(String[] args) {
        // 方法代码块（局部代码块）：控制变量的生命周期

        int j = 9;
        {
            //运行完成后，在内存中将i清除
            int i = 8;    
            System.out.println(i + j);
        }
    }
}

 

成员变量与局部变量的区别

成员方法----方法类内普通方法

1.位置

　　局部变量：方法里或者代码块内

　　成员变量：方法外内内

2.适用范围

　　局部变量：整个方法或者代码块

　　成员变量：整个类

3.在内存中的存储位置

　　局部变量：栈

　　成员变量：堆

4.生命周期

　　局部变量：方法被调用，或者执行代码块开始产生，

　　方法调用结束，或者代码块执行完毕而消除

　　成员变量：随着对象的创建而产生，随着对象被回收而销毁

 

面向对象的特征

　　以前：封装，继承，多态 现在： +（抽象）

封装：体现形式（方法），属性私有化

　　体现形式（方法），属性私有化（通过提供公共的访问方式仍然可以进行正常的赋值，取值提高代码的安全性）

封装的java实现

public class Test {
    public static void main(String[] args) {
​
        // 创建对象
        person p = new person();
        p.setAge(10);
        System.out.println(p.getAge());
    }
}
​
class person {
​
    //私有化属性
    private int age;
​
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        if(age<0){
            System.out.println("年龄不合法");
        }else{
            this.age = age;
        }
        
    }
​
}

 

继承：

　　多个类含有相同的内容，把这些相同的内容放到一个新的类中，让原来的这些类通过该extends 关键字 和新类产生了关联关系，新类是父类，原来的类是子类，派生类

　　子类可以拿到父类的部分内容

继承的方式

　　java支持类与类之间是单继承【一个子类只能有一个父类，一个父类可以有多个子类】

　　c语言支持多继承

继承的java实现

public class Test {
    public static void main(String[] args) {
        // 创建子类对象
        Doctor d = new Doctor();
        d.name = "asda";
        d.treat();
        
    }
}
​
// 父类，超类
class xin {
    // 属性
    String name;
    int age;
    char gender;
​
    // 科室
    String dept;
​
    // 方法
    public void treat() {
        System.out.println(this.name + "在治病救人..");
    }
}
​
// 医生类---子类
// 通过extend关键字，使医生类和xin类产生关系
class Doctor extends xin {
​
}
​
// 护士类
class Nurse extends xin {
​
}

 

多态

　　在程序操作过程中代码的多种展现形式

　　java时期:编译时期，运行时期

　　编译时期： ————在编译时期进行代码的绑定-----》编译时多条

　　例如：

　　　　public static void m(){ }

　　　　public static void m(int i){ }

　　运行时期：--------------在运行时期进行代码的绑定-----------》运行时多态

　　例如：

　　　　重写，向上造型

 

多态的优点：1.参数化统一 2. 功能统一调用 3.解耦（降低耦合度）

向上造型(运行时多态的一种表现)：创建的对象调用具体的方法（重写），方法的执行看子类

　　可以调到哪些方法看父类，具体执行看子类

例如:

public class Animal {
    public static void main(String[] args) {
        //声明的是父类，实际创建的类是子类---向上造型
        pet p= new dog();;
        
        //调用方法
        p.eat();
//        p.bark();--------------bark是dog中的方法，所以错误
        p.sleep();
        
        m(new cat());    //-----也是向上造型的一种用法
    }
    
    public static void m(pet p){
        System.out.println(p);
    }

}

class pet {
    public void eat() {
        System.out.println("悠闲地吃东西");
    }

    public void sleep() {
        System.out.println("在悠闲地睡觉");
    }

}

class dog extends pet {
    public void eat() {
        System.out.println("在呼呼的吃东西");
    }

    public void bark() {
        System.out.println("在汪汪的吃东西");
    }
}

class cat extends pet {
    public void eat() {
        System.out.println("在虎虎虎的吃");
    }

    public void mm() {
        System.out.println("在磨爪子");
    }
}