类和对象

类和对象

1.类和对象的概念

1. c语言是面向的过程，关注的是过程，就是所涉及的行为，功能。
2. java是面向对象的，整个参与过程所涉及的主体，是通过逻辑将一个个功能连接起来，类就是一类对象的统称，对象就是一个类具体化的实例；一个类主要包含一个事物的属性和行为。
3. 类属于引用类型，使用关键字class来声明，一个类可以产生多个对象

2.类和对象的实例化

实例化：用例创建对象的过程

Person   person1=new   Person();//实例化对象  通过new来创建一个对象的实例
Person    person2=new Person();
        person1.age=28;
        person1.name="xiaozhan ";
        person1.sex="man";
        person1.eat();
        person1.sleep();
        System.out.println(person1.name);
    }//  吃饭  睡觉   xiaozhan 
}

class  Person{//类的名称
    public  int age;//成员属性  成员变量   实例变量
    public String sex;//字段
    public String name;
public  void eat(){//类方法  行为  成员方法
    System.out.println("吃饭");
}
    public  void sleep(){
        System.out.println("睡觉");
    }
}

``
一个字段如果没有显示设置初始值，那么初始值为默认值
数字类型，默认值为0
boolean类型，默认值false
引用类型，默认值null

Person   person1=new   Person();
        System.out.println(person1.name.length());//java.lang.NullPointerException
    }
    
}
class  Person{
    public  int age;
    public String sex;
    public String name;
}

3.static关键字

1.修饰属性
类变量

count被static所修饰，和类相关不依赖于对象；同一个类的不同实例所共享

类名.属性去访问

public class Ma {
    public static void main(String[] args) {
       M   m1=new   M();
       m1.a++;
       M.count++;
        System.out.println(m1.a);
        System.out.println(M.count);
        M    m2=  new  M();
        System.out.println("=======");
        m2.a++;
        M.count++;
        System.out.println(m2.a);
        System.out.println(M.count);
    }//1 1  ======= 1    2
}
class  M{
    public  int a;
    public static  int  count;
}

2.修饰方法
类方法

public class Ma {
    public static void main(String[] args) {
            M.chang();//不用创建实例，就可以调用
        System.out.println(M.count);
    }
}
class  M{
    public  int a;
    public static  int  count;
    public static  void chang(){
        count=10;
        //int a=10;不可以访问非静态成员
    }
}

》》静态方法属于类，而不属于类的对象
》》可以直接调用静态方法，无需创建类的实例，类.方法名去访问
》》静态方法可以访问静态成员

为什么静态方法内部不可以直接访问非静态成员和非静态方法?
静态的方法不依赖于对象，对象是否产生不影响调用静态方法；非静态的成员依赖于对象，对象被实例化之后产生

实例对象可以访问静态方法和静态属性（不建议）
实例方法可以直接调用静态方法和静态属性，默认类名.方法，类名.属性

为什么main是static?
如果不是静态的，那么main函数的调用需要对象，但是main程序的入口，无法生成一个实例

3.修饰代码块
4.修饰类

public final int SIZE=10；//被final所修饰为常量也属于对象，放在堆中，通过引用访问

public static final int SIZE=10；//静态的常量。属于类本身，且只有一份

 M    m1=new  M( );   
     m1.SIZE=10;
class  M{
    public  static  int SIZE=10;
    }
}

4. 封装

1.概念：让调用者不必太多的了解类的实现者是如何实现类的，只知道如何使用类就行

作用：降低了类使用者的学习和使用成本，降低了复杂度

private不能被类的调用者使用
可以修饰字段也可以修饰方法
字段使用private来修饰，类的调用者（main方法中）不能直接使用，需要借助getter和setter方法

public可以被类的调用者使用

5.getter和setter

public class Ma {
    public static void main(String[] args) {
           M   m1= new   M();
           m1.setName("xiaozhan");
          String   name= m1.getName();
        System.out.println(name);//不创建实例，
        m1.chang();
    }//xiaozhan    xiaozhan 0
}
class  M{
    private  int  age;
    private  String  name;
    public   void chang(){
        System.out.println(name+age);
    }
    public void setName(String name ){
        this.name=name;
    }
    public String    getName(){
        return name;
    }
}

this 代表什么？
当前对象的引用；
this（ )必须放在第一行；

6. 构造方法

作用：初始化对象

构造是一种特殊方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作
new执行过程：
》》为对象分配内存空间
》》调用对象的构造方法

 public class Ma {
    public static void main(String[] args) {
           M   m1= new   M();
           m1.chang();
           M   m2=new   M("cacao",80);
           m2.chang();

    }
}
class  M{
    private  int  age;
    private  String  name;
    public   void chang(){
        System.out.println(name+age);
    }
           public    M(){//默认构造函数
        this.name="ma";
        this.age=20;
           }
           public   M(String  name,int age){//带有2个参数的构造方法
               this.name=name;
               this.age=age;
           }
 

》》构造方法名称必须与类相同；
》》构造方法没有返回值类型声明
》》每一个类中至少存在一个构造方法，没有明确定义则系统会默认生成一个无参构造
》》若类中定义了构造方法，则默认的无参构造将不再生成
》》构造方法支持重载

7.this关键字

this当前对象的引用，可以借助this来访问对象的字段和方法

public class Ma {
    public static void main(String[] args) {
           M   m1= new   M();
           m1.chang();
           M   m2=new   M("cacao",80);
           m2.chang();

    }
}
class  M{
    private  int  age;
    private  String  name;
    public   void chang(){
        System.out.println(name+age);
    }
           public    M(){
        //this调用构造函数
        this("xiaozhan",28);
           }
           //这两个构造函数的关系为重载
           public   M(String  name,int age){
               this.name=name;
               this.age=age;
           }
}

8.代码块

什么是代码块？

{}定义的一段代码

1.普通代码块:定义在方法内的代码块

2.构造块（实例代码块）：用于初始化实例成员变量，优先于构造函数执行

3.静态块：初始化静态成员属性
static{}
静态代码块不管生成多少对象，只会执行一次，最先执行

4.同步代码块（多线程）

执行顺序：
静态代码块
实例代码块
构造函数

toString（）方法可以将对象转换成字符号串，这种操作成为序列化
可以重写Object的toString（）方法
IDEA快速生成Object的toString 方法：alt+f12

9.匿名对象：

匿名：没有名字的对象

• 没有引用的对象成为匿名对象
• 匿名对象只在创建对象时使用
• 如果一个对象只是使用一次，后面不在使用，可以考虑匿名对象