java--面向对象简介

面向对象简介

1.面向对象和面向过程的区别

面向对象：
	本质是一种编程范式（一种套路、一种思考方式）
面向过程：关注的是每行代码实现细节
面向对象：先把代码实现细节整合到对象身上，
	 只要找到对象就能拥有对象身上的功能（万物皆对象）
面向对象基于面向过程
如果场景比较复杂推荐使用面向对象， 如果场景比较简单优先推荐面向过程

2.类和对象的关系

对一类对象进行抽取，把共同的特征信息抽取成了属性，把共同的行为抽取成了方法，
把这些对象抽取成了对应的类。

类是对对象的概括，对象是对类的具体实现。

package cn.tedu.object;

public class objectDemo {
    public static void main(String[] args) {
        //创建Person类的对象
        Person person = new Person();
        //.代表“的”的意思
        //操作的是对象p的属性
        person.name="丽丽";
        person.age=12;
        person.gender='女';
        person.eat();//丽丽在吃饭。。。
        //对象地址值---cn.tedu.object.Person@28d93b30
        System.out.println(person);//[[F@28d93b30
    }
}
//定义Person类---代表人
class Person{
    //特征信息---属性(变量)
    String name;
    char gender;
    int age;

    //
    public void eat(){
        System.out.println(name+"在吃饭。。。");
    }
    public void sleep(){
        System.out.println(name+"在睡觉。。。");
    }
}

3.构造方法

构建对象 
形式：1.没有方法返回值类型、2.方法名与类同名 
构造方法支持重载 
如果类中没有定义构造方法会默认提供无参构造，如果类中定义构造方法就不会默认提供无参构造 
一个类中至少含有一个构造方法
java中所有的非静态方法和属性只能通过对象调用

package cn.tedu.object;

public class ObjectDemo {
    public static void main(String[] args) {
        //创建Person类的对象
        //调用构造方法来创建对象---构造方法是来构建对象
        Person p=new Person("tom");//对象p
        //.代表“的”的意思
        //操作的是对象p的属性
        //p.name="丽丽";
        p.age=12;
        p.gender='女';
        //调用方法
        p.eat();//java中所有的非静态方法和属性只能通过对象调用
        //对象地址值---cn.tedu.object.Person@28d93b30
        System.out.println(p);
        Person.eat();//报错    java中所有的非静态方法和属性只能通过对象调用
        Person.eat2();//不会报错

    }
}
//定义Person类---代表人
class Person{
    //特征信息---属性（变量）
    //不加static修饰的属性就是非静态属性
    //成员变量
    String name;
    char gender;
    int age;

    //如果类中没有定义构造方法JVM会默认在底层提供一个无参构造
    //如果类中有定义构造方法JVM不会默认在底层提供一个无参构造
    //构造方法：1.没有返回值类型  2.方法名与类同名
    //构造方法支持重载
    //public Person(){}//无参构造
    //与类同名的普通方法
    //public static void Person(){}
    //有参构造(构建对象，初始化属性)
    public  Person(String name){//方法的就近原则
        //this代表当前类的对象
        this.name=name;
    }

    //行为---方法
    public  void eat(){
        int i=1;//局部变量
        System.out.println("只能用对象来调用这个方法，不能用类名来调用");
    }
    public static void eat2(){
        int i=1;//局部变量
        System.out.println("可以用类名来调用,也可以用对象来调用");
    }
  
    public void sleep(){
        System.out.println(name+"在睡觉。。。");
    }
}

4.this

a.关键字，代表当前类的对象 
b.this可以代表还没有创建对象、可以代表刚创建对象、可以代表正在使用的对象，
  this是一个虚拟的对象通过指定对 象地址值来代表对象，代表的就是当前类正在活动的对象。
c.this语句，在构造方法中去调用别的构造方法，使用在构造方法的首行 

package cn.tedu.object;

public class ThisDemo {
    public static void main(String[] args) {
        //创建Student对象
        Student s1=new Student();
        //this代表刚创建的对象
        System.out.println("s1:"+s1);
        //创建Student对象
        Student s2=new Student("tom");
        //this代表正在使用的对象
        System.out.println("s2:"+s2);
        //this代表正在活动的对象
        s1.study("Ben");
    }

}
//代表学生的类
class Student{
    //非静态属性
    String name,n;
    int age;
    char gender;

    //无参构造
    public Student(){
            System.out.println("this:刚创建的对象"+this);
        }

    //有参构造
    public Student(String name){
            n=name;
            this.name=name;
            System.out.println("this:正在使用的对象"+this+"name:"+name+"n:"+n);
    }
    //有参构造
    public Student(String name,int age){
        //this.name=name;
        //this()---this语句
        //调用构造方法，只能在首行使用
        this(name);
        this.age=age;
        //System.out.println("this:"+this);
    }

    //行为
    public void study(String name){
        //this可以代表当前类还没有产生的对象
         int m;
        n=name;
        this.name=name;
        System.out.println("this:正在活动的对象s1"+this+"name:"+name+"n:"+n);
        //System.out.println(this.name+"在学习。。。");
        //System.out.println("this:"+this);
    }
}

5.构造代码块

在类内方法外位置{} 
构造代码块可以给属性进行初始化，优先于构造方法先执行 

package cn.tedu.object;

public class ObejctDemo2 {
    public static void main(String[] args) {
        //创建婴儿类对象
        Baby b=new Baby();
        System.out.println(b.name+","+b.age);
    }
}



//定义代表婴儿的类,创建类的对象代表真实的婴儿出生
//孕妇希望自己的孩子出生时名字叫“莉莉”年龄是一岁
class Baby{
    //属性
    String name;
    int age;
    char gender;

    //构造代码块优于所有的构造方法先执行
    {
        this.name="莉莉";
        this.age=1;
        System.out.println("构造代码块");
    }
    
    //无参构造(没有指定名字和年龄)
    public Baby(){
       /* this.name="莉莉";
        this.age=1;*/
        System.out.println("无参构造");
    }
    
    //有参构造(有指定名字)
    public Baby(String name){
        //this.name=name;
       /* this.name="莉莉";
        this.age=1;*/
    }
    
    //有参构造(有指定名字和年龄)
    public Baby(String name,int age){
        /*this.name=name;
        this.age=age;*/
        /*this.name="莉莉";
        this.age=1;*/
    }
    //行为
    public void cry(){
        System.out.println(name+"在嗷嗷的哭。。。");
    }

}

6. 局部代码块

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

package cn.tedu.object;

public class ObjectDemo3 {
    public static void main(String[] args) {
        int x=1;
        
        //局部代码块---控制变量的生命周期
        {
             int y=2;
            System.out.println(x+y);
        }
        System.out.println(y);//编译报错
        //后面有1000行代码都没有使用变量x和y
    }
}

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

定义位置
	成员变量：类内方法外
	局部变量：方法内
使用范围
      	成员变量：整个类
      	局部变量：整个方法
内存位置
 	成员变量：堆里
 	局部变量：栈里
生命周期
 	成员变量：随着对象的创建而产生，随着对象被回收而销毁
 	局部变量：随着方法被调用执行才产生，随着方法调用执行结束而销毁