类和对象

• 面向对象和面向过程

面向对象

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

面向过程

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；

区别

1. 面向过程注重的是过程，在整个过程所涉及的行为就是功能
2. 面向对象注重的对象，也就是参与过程中个所涉及的实主体，通过逻辑将一个一个的功能连接起来

例如五子棋：

面向过程的设计思路就是首先分析问题的步骤：
1、开始游戏， 2、黑子先走， 3、绘制画面， 4、判断输赢， 5、轮到白子， 6、绘制画面， 7、判断输赢， 8、返回步骤2， 9、输出最后结果。 把上面每个步骤用分别的函数来实现，问题就解决了。

面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为：
1、黑白双方，这两方的行为是一模一样的， 2、棋盘系统，负责绘制画面， 3、规则系统，负责判定诸如犯规、输赢等。

• 类和对象

类是一类对象的统称，对象就是这一类具体化的一个实例

类相当于一个模板，对象是由模板产生的样本，一个类可以产生无数个模板

基本语法

// 创建类
class class_name{  
    field;//成员属性
    method;//成员方法
}
//实例化对象
class_name 对象名=new class_name();

class为类的关键字
class_name为类的名字
{}为类的主体
类中的元素称为：成员属性
类中的函数称为成员方法

示例

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

• 类的成员

字段，方法，代码块，方法，接口等

字段

在类中, 但是方法外部定义的变量. 这样的变量我们称为== “字段” ==或 “属性” 或 “成员变量”(三种称呼都可以, 一般不会严
格区分).

class Person {
    public String name;   // 字段
    public int age; 
    public static void main(){};
}

注意事项

1. 使用 . 访问对象的字段
2. 访问既包含读，也包含写
3. 对于一个对象的字段没有设置初始值，就会被设置一个默认的初始值

默认规则
对于各种数字类型默认值为0
对于boolean类型默认值为false
对于引用类型(String,Array,以及自定制类)默认值为null
null在java中是空引用表示不引用任何对象，如果d对null进行点 **(.)**操作就会出现空指针异常

• 方法

描述一个对象的行为

方法内部定义的变量叫做局部变量

构造方法

方法名类名相同没有返回值，在实例化对象的时候（new一个对象的时候）会自动调用的方法用于对象的初始化

• static关键字

修饰属性

java静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同对象公用同一个静态属性

修饰方法

1. 静态方法属于类而不属于类的对象
2. 可以直接调用静态方法而无需创建类的实例
3. 静态方法可以访问静态数据成员，并可以更改静态数据成员的值

局部变量和局部变量初始化问题

成员变量可以不初始化有默认值，而局部变量必须初始化

注意

1. 静态成员变量依赖于类，不属于对象，有一份存在方法区，依赖于类 所有对象共享，通过类名来访问，虽然对象也可以访问但是会报警告。
   静态成员方法对象可以访问，但是对于静态成员变量和静态成员方法来说不关心你的对象是否存在，哪怕是个nul也可以
2. 静态方法内不能直接调用非静态方法，不能访直接问非静态成员变量，只能访问静态的成员变量和静态成员方法
3. 非静态方法内可以访问静态成员变量和静态成员方法，也可访问非静态成员变量和非静态成员方法
4. 局部变量一定要先初始化后使用
5. 普通成员方法内部不能定义静态成员变量，但是可以访问
6. 方法的地址在方法区，
7. Java文件中一个类会生成一个类文件件(.class二进制字节码)，因为jvm是你用哪个类我就用哪个类的字节码文件

从访问形式上，静态的成员和方法通过类名来访问，不依赖于对象
从内存上看，被static修饰的都在方法区其他的不是在栈就是在堆上，局部变量在栈上，成员变量属于对象在堆上，成员变量也在堆上

对比静态和非静态的访问

public class Person {
    public int age;//成员属性 实例变量
    public static String name;//静态成员变量
    public String sex;
    //类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
    public static int count;
    //被final修饰的叫常量，属于对象,后续不可改变
    public final int SIZE=0;
    //静态的常量，属于类本身，只有一份，被final修饰，后续不可修改
    public static final int COUNT=999;
    //非静态成员方法-依赖于对象
    public void eat() {
        //age为成员变量作用域就整个类括号，可以直接写
        age=0;

        //this关键字的一个作用就是访问成员变量，就是this的一个作用你也可以不用
        this.age=0;

        //name静态成员变量作用域也是整个类
        name="zpf";

        /*name依赖于类，所有对象共享此变量，但是可以用对象(this)访问，会报警告，
        不建议使用它会和非静态访问混淆，不安全
        */
        this.name="zpf";

        //name就依赖于类,类名访问是可以的
        Person.name="zpf";

        /*非静态成员方法可以直接访问静态成员方法
        静态成员成员方法依赖于类,非静态成员方法依赖于对象，
        当你访问非静态成员方法时，肯定会先创建对象，
        证明这个类已经存在了，就可以访问静态成员方法
        */
        sleep();

        //这种如同对象调用成员变量一样，报警告，不建议使用
        this.sleep();

        //sleep()就是静态成员方法依赖于类，用类名访问
        Person.sleep();

        //成员方法 作用域类的大括号
        walk();

        //成员方法依赖于对象，也是this关键字的一个作用
        this.walk();

        //报错依赖于对象不依赖于类
        //Person.walk();
        System.out.println("吃饭!");

    }
    //静态成员方法-依赖于类
    public static void sleep() {
        /*
        静态成员方法不能直接访问非静态成员变量，
        因为当前的方法是静态的依赖于类，可以不用对象就可已访问
        而age依赖于对象必须创建对象才能访问
        调用这个方法时还不用对象，age就不能访问
        */
        //age=0;

        //this表示当前方法的对象的引用，但是当前方法时静态的不依赖于对象，矛盾不成立
        //this.age=0;

        //错误 因为age依赖域对象不依赖于类
        //Person.age=0;

        //name是静态的依赖于类，直接使用是作用域在这个类的大括号
        name="zpf";

        //依赖于类可以通过类名调用
        Person.name="zpf";

        //错误this表示当前方法的对象的引用，可是当前方法时静态不依赖于对象
        /*this.name="zpf";
           eat();
          this.eat();
          //this.run();
         */
        //Person.eat();
        //run是静态方法依赖于类可以直接用
        run();
        Person.run();
        System.out.println("睡觉!");
    }
    //静态成员方法
    public static void run(){
        System.out.println("run");
    }
    //非静态成员方法
    public void walk(){
        System.out.println();
    }
    public static void main(String[] args) {
    }
}

• 封装

什么叫封装

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度

private实现I封装

private/ public 这两个关键字表示 “访问权限控制” .
被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.
换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类.

• 构造方法

定义

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.

new 执行过程

1. 为对象分配内存空间
2. 调用合适对象的构造方法（构造方法不止一个）

语法规则

1. 方法名称必须和类名称相同
2. 构造方法没有返回值类型说明
3. 每一类中至少存在一个构造方法(没有明确定义，系统自动生成一个无参构造方法)

注意事项

1. 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
2. 若类中定义了构造方法，则默认的无参构造将不再生成.
   构造方法支持重载，规则和普通方法一致

• this

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

剖析下this不是对象

class Person{
	public int age;
	public String name;
	pubhlic Person(int age){
		this.age=age;
		System.out.printlln("你好);
	}
}

构造函数内部使用了this，而构造函数是用来创建对象，对象还没有创建好，就使用了this,这样的话你能说this还是代表对象吗，当然不能，他只是一个引用

this的作用

1. this.成员变量(成员变量一定是普通的成员变量不是局部变量)
2. this();//个访问构造方法必须位于方法内部的第一行代码
3. this.成员方法

• 代码块

字段初始方式

1. 就地初始化
2. 使用构造方法初始化
3. 使用代码块初始化

代码块

使用{}定义的一段代码

1. 普通代码块/本地代码块
2. 构造代码块/示例代码块
3. 静态代码块
4. 同步代码块

普通方法块

public class Main{ 
 public static void main(String[] args) { 
 { //直接使用{}定义，普通方法块
 int x = 10 ; 
 System.out.println("x1 = " +x); 
 } 
 int x = 100 ; 
 System.out.println("x2 = " +x); 
 } 
}

构造代码块

定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person{ 
 private String name;//实例成员变量
 private int age; 
 private String sex; 
 
 public Person() { 
 System.out.println("I am Person init()!"); 
 } 
 
 //实例代码块
 { 
 this.name = "bit"; 
 this.age = 12; 
 this.sex = "man"; 
 System.out.println("I am instance init()!"); 
 } 
 
 public void show(){ 
 System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
 } 
 
} 
public class Main { 
 public static void main(String[] args) { 
 Person p1 = new Person(); 
 p1.show(); 
 } 
}

静态代码块

使用static定义的代码块。一般用于初始化静态成员属性

class Person{ 
 	private String name;//实例成员变量
 	private int age; 
 	private String sex; 
 	private static int count = 0;//静态成员变量 由类共享数据 方法区

 	public Person(){ 
 		System.out.println("I am Person init()!"); 
 	} 
 
 	//静态代码块
 	static { 
		count = 10;//只能访问静态数据成员 
 		System.out.println("I am static init()!"); 
 	} 
 
 	public void show(){ 
 		System.out.println("name: "+name+" 		age: 	"+age+" sex: "+sex); 
 	} 
 
}

注意

1. 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
2. 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

• toString()方法

1. toString 方法会在 println 的时候被自动调用.
2. 将对象转成字符串这样的操作我们称为 序列化.
   toString 是 Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object 类, 可以重写 toString 方法实
3. @Override 在 Java 中称为 “注解”, 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法.

• 匿名对象

1. 匿名只是表示没有名字的对象.
2. 没有引用的对象称为匿名对象.
3. 匿名对象只能在创建对象时使用.
   4。 如果一个对象只使用一次, 后面不需要用了, 可以考虑使用匿名对象.

class Person { 
 private String name; 
 private int age; 
 public Person(String name,int age) { 
 this.age = age; 
 this.name = name; 
 } 
 public void show() { 
 System.out.println("name:"+name+" " + "age:"+age); 
 } 
} 
public class Main { 
 public static void main(String[] args) { 
 new Person("caocao",19).show();//通过匿名对象调用方法
 } 
}

• 匿名数组

class Test{
	public static void fun(int[] args){}
	public static void main(String[] args){
		int[] arr={1,2,3,4,5};
		fun(new int[]{1,2,3,4,5});//匿名数组
	} 
}

• 可变参数

class Test{
	public static int fun(int... b){
		int sum=0;
		for(int i=0i<b.length;i++){
			sum+=b[i];
		}
		return sum;
	}
	public static void main(String[] args){
		int[] arr={2,3,4,1};
		System.out.println(fun(arr));
		System.out.println(fun(1,2,3,4,5));
		System.out.println(fun(new{2,3,4,1}));
	}
}

• 总结

1.一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
2. 类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的
3. 方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
4. 静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
5. this关键字代表的是当前对象的引用。并不是当前对象。