Java 类与对象

产生原因：便于数据管理
数组的话数据类型不能有效的体现。
创建一个对象 = 实例化一个对象 = 把……实例化

类是抽象的、概念的，代表一类事物（模板）
对象是具体的

创建对象

Cat cat;
cat = new Cat();

Cat cat = new Cat();

成员方法

import java.util.*;
public class Method01{
		public static void main (String[] args){
			// using methods:
			// create an object -> use it!
			Person p = new Person();
			p.speak();
			
			System.out.println("cal 1 ~ 1000:");
			p.Cal01();
			
			System.out.println("cal 1 ~ n, please input n:");
			Scanner scanner = new Scanner(System.in);
			int n = scanner.nextInt();
			p.Cal02(n);
			
			int res = p.getSum(10, 20);
			System.out.println(res);
		}
}
class Person{
	String name;
	int age;
	// public means 
	// void means no return
	public void speak(){
		System.out.print("You are a good person~\n");
	}
	
	public void Cal01(){
		int sum = 0;
		for (int i = 1; i <= 1000 ; i++){
			sum += i;
		}
		System.out.println("1 + 2 + ..1000 is " + sum );
	}
	
	public void Cal02(int n){
		int sum = 0;
		for (int i = 1; i <= n ; i++){
			sum += i;
		}
		System.out.println("1 + 2 + .." + n +" is " + sum );
	}
	
	// int means it has --> return
	public int getSum(int a, int b){
		int sum = a + b;
		return sum;
	}
}

打印二维数组

public class MethodExercise03{
	public static void main (String[] args){
		int[][] arr = {{1,2},{3,4},{5,6}};
		MyTools mt = new MyTools();
		mt.printTwoDemensionArr(arr);
	}
}

class MyTools{
	public void printTwoDemensionArr(int[][] arr){
		for(int i = 0; i < arr.length; i++){
			for(int j = 0; j < arr[i].length; j++){
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}

克隆对象

编写一个方法copyPerson，复制一个Person对象，返回复制的对象。克隆对象。两个对象只是属性相同。

public class MethodExercise03{
	public static void main (String[] args){
		Person p = new Person();
		p.name = "Zhangsan";
		p.age = 88;
		
		MyTools mt = new MyTools();
		Person p2 = mt.copyPerson(p);
		
		System.out.println("p age " + p.age + "p name :" + p.name);
		System.out.println("p2 age " + p2.age + "p2 name :" + p2.name);
	}
}

class MyTools{
	public Person copyPerson(Person p){
		Person p2 = new Person();
		p2.name = p.name;
		p2.age = p.age;
		return p2;
	}
}

class Person{
	String name;
	int age;	
}

可变参数

当作数组 放在最后 只能一个

public class VarParameterExercise{
	public static void main (String[] args){
		Method mt = new Method();
		String name = "LiMing";
		System.out.println(mt.showScore(name,33,22));
		System.out.println(mt.showScore(name,33,22,66));
		System.out.println(mt.showScore(name,33,22,77,77,99));
	}
}

class Method{
	int sum = 0;
	public String showScore(String name, int... score ){
		for(int i = 0; i < score.length ; i++){
			sum += score[i];
		}
		return name + ":" + sum;
	}
}

变量作用域

全局变量可以直接使用，有默认值
局部变量不可以直接使用，没有默认值

全局变量不在一个class里可以新建对象，通过对象调用；还可以t.test(p)，把对象传进去调用
局部变量只能方法体内用

全局变量可以加修饰符
局部变量不能加修饰符

构造方法/构造器 Constructor

前面是 先创建对象，再赋值
如果要求 创建对象时，就直接指定这个对象的年龄和姓名
那么就需要使用构造器/构造方法
↓
完成对对象的初始化

[修饰符] 方法名(形参列表){
方法体
}

1. 构造器没有返回值
2. 方法名和类名必须一样
3. 参数列表 和 成员方法一样的规则
4. 创建对象时，系统自动完成构造器的调用
5. 一个类可以定义多个不同的构造器，即构造器重载
6. 构造器是完成对象的初始化，不是创建对象
7. 如果程序员没有定义构造器，系统会自动给类生成一个默认的无参构造器P(){}，可以通过javap对class文件进行反编译
8. 一旦定义了子集的构造器，默认的构造器就覆盖了，除非声明。

public class Constructor{
	public static void main (String[] args){
		Person p1 = new Person("smith", 80);
		System.out.println("name: " + p1.name);
		
		Person p0 = new Person();
		System.out.println("name: " + p0.name + "age:"+p0.age);//"" 18
	}
}

class Person{
	String name;
	int age;
	
	// constructor0
	public Person(){
		age = 18;
	}
	// constructor1
	// no return
	public Person(String pName, int pAge){
		name = pName;
		age = pAge;
	}
	
	// constructor2
	public Person(String pName){
		name = pName;
	}
}

流程分析 面试要考

1. 方法去加载Person类，只会加载一次
2. 堆中开辟对象空间，会得到一个地址
3. 完成对象初始化
   1）先进行默认初始化
   2）再显式初始化（局部变量）
   3）再构造器赋值
4. 在对象在堆中的地址，返回给对象名

this

原因：想把构造器的形参直接写成属性名，更加友好一点
this指的是当前对象，哪个对象调用，this就代表哪个对象

class Person{
	String name;
	int age;
	// 构造器的name 是局部变量而不是属性
	// 构造器的age 是局部变量而不是属性
	public Person(String name, int age){
			// 当前对象的属性name 就是 this.name 
			// 
			this.name = name;
			this.age = age;
		}
}

1. this 访问本类 属性、方法、构造器
2. this 用来区分当前属性和局部变量
3. this.方法名(参数列表) 访问成员方法
4. this(参数列表) 访问构造器的语法（只能在构造器中使用，必须放在第一条语句）
5. this不能在类外边使用，只能在类定义的方法中使用

this 找当前对象的属性

判断两人姓名年龄一致

public class TestPerson{
	public static void main (String[] args){
		Person p1 = new Person("mary", 20);
		Person p2 = new Person("tom", 30);
		System.out.println(p1.compareTo(p2));
	}	
}
class Person{
	String name;
	int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public boolean compareTo(Person p){
		return this.name.equals(p.name) && this.age == p.age;
	}
}

prac:查找某个字符串是否在数组，是返回下标，否返回-1

public class FindString{
	public static void main (String[] args){
		A02 a = new A02();
		String[] arr = {"asd", "ppp", "aaa"};
		String str = "ppp";
		int res = a.find(arr, str);
		System.out.println(res);
	}
}
class A02{
	public int find(String arr[], String str){
		int flag = -2;
		for(int i = 0; i < arr.length; i++){
			if(arr[i].equals(str)){
				flag = i;
				break;
			}else{
				flag = -1;
			}
		}
		return flag;
	}
}

class A02{
	public int find(String arr[], String str){
		for(int i = 0; i < arr.length; i++){
			if(arr[i].equals(str)){
				return i;
			}
		}
		return -1;
	}
}

practice: 如果>150 price 改为 150 如果>100 改为100

public class ChangePrice{
	public static void main (String[] args){
		Book book = new Book("Linear Algebra",133);
		book.info();
		book.updatePrice();
	}	
}
class Book{
	String name;
	int price;
	public Book(String name, int price){
		this.name = name;
		this.price = price;
	}
	public void updatePrice(){
		int price = 1000;
		if(this.price > 150){
			this.price = 150;
		}else if(this.price > 100){
			this.price = 100;
		}
		this.info();
	}
	public void info(){
		System.out.println(this.name +" : "+this.price);
	}
}

practice 通过包装类返回空

public class Operate{
	public static void main (String[] args){
		Cale cale = new Cale(3,0);
		System.out.println("a + b = " + cale.add());
		System.out.println("a - b = " + cale.minus());
		System.out.println("a * b = " + cale.mul());
		Double divRes = cale.division();
		if(divRes != null){
			System.out.println("a / b = " + cale.division());
		}
	}		
}

class Cale{
	double a;
	double b;
	public Cale(double a, double b){
		this.a = a;
		this.b = b;
	}
	public double add(){
		return a + b;
	} 
	public double minus(){
		return a - b;
	} 
	public double mul(){
		return a * b;
	} 
	public Double division(){
		if(b == 0){
			System.out.println("Please change b.");
			return null;
		}else{
			return a / b;
		}
	} 
}

匿名对象

没有名字的对象，只能用一次

new Test().count1();