封装-this-static

一.匿名对象

定义： 没有名字的对象。

意义：节省代码，并且很多情况下是针对某个方法只需要调用一次的情况下。

匿名对象可以调用方法，也可以给成员变量赋值。同时也可以作为方法的 参数进行传递。主要的作用就是节省代码量，使代码结构更优雅。

public class DemoTest{
	public static void main(String[] args){
	/*
		Person person = new Person();
		person.name = "luona";
		person.age = 20;
		person.speak();
	*/
	
	
	/*	
		new Person().name ="luona";			//匿名对象访问，对象创建完就被垃圾回收器回收，因为没有地址引用
		new Person().age = 20;
		new Person().speak();
	
		new Person("luona",20).speak();      //匿名对象给成员变量赋值
	
	*/
	
		Person person = new Person();
		person.initPerson(person);
		person.speak();
		
		initPerson(new Person()).speak();   //匿名对象作为方法的参数进行传递
	}
	
	//定义的名称，是针对person对象初始化的。
		static Person initPerson(Person person){ 
		person.name = "luona";
		person.age = 20;
		return person;
	}
	
		
	
}

class Person{
	String name;
	int age;
	
	Person(){
		
	}
	/*
	Person(String nameParm,int ageParm){
		String name = nameParm;
		int age = ageParm;
	}
	*/

	
	void  initPerson(Person person){
		person.name = "luona";
		person.age = 20;
		
	}
	
	

	void speak(){
		System.out.println("speak:"+name+" . "+age);
	}
}

二.封装

1.概念：隐藏对象的属性和细节，仅对外提供公共的方法进行访问。

2.private:

a.当类的成员变量使用private进行修饰，那么就不可以直接访问到该成员变量。

b.当使用private修饰的成员变量或者成员方法，仅能在本类中使用。

c.private对于main方法的修饰，也是可以产生作用的。

public class DemoPrivate{
	
	
	public static void main(String[] args){
		Person person =new Person();
		person.name = "diffo";
		person.setAge(-1);
		//person.eat();//error
		person.action();	          //可以通过action()访问得到eat();		
	}
	
}

class Person{
	String name;
	private int age;				//隐藏对象的属性，可提供set和get方法提供对外的访问
	
	void setAge(int ageParm){
		if(ageParm>0 && ageParm<150){
			age = ageParm;
		}
	}
	
	private void eat(){					//用private对eat()进行私有化，则在主方法中不能直接访问到
	   System.out.println("eat");	
	}
	
	void action(){						
		eat();
		speak();
	}
	
	void speak(){
		System.out.println("speak!: "+name+" . "+age);
	}
}

javaBean：是这样一类的类：他的所有成员变量都使用private进行修饰，并且对外提供可访问的设置值和获取值的set,get方法。不同的应用场景，可能命名不同，数据库的应用中称为POJO类。

public class DemoBean {

	/*
	  注意一种特殊的类java bean,成员变量私有化，对属性设置set()(void类型)和get()方法(和成员变量的类型一致)；
	 */
	public static void main(String[] args) {
		Telephone phone = new Telephone();
		phone.setName("苹果");
		phone.setType("iphone7");
		phone.setPrice(4500);
phone.getInfo();
		//phone.getInfo("iphone7","苹果",4500);
		phone.call(123456);
	}
}

class Telephone{
   private String name;
   private String type;
   private int price;
   private int num;
   
	void setName (String nameParm){
		 name = nameParm;
	}
	String getName(){
		return name;
	}
	
	void setType(String typeParm){
		 type = typeParm;
	}
	String getType(){
		return type;
	}
	
	void setPrice(int priceParm){
		 price = priceParm;
	}
	int getPrice(){
		return price;
	}
	
	void setNum(int numParm){
		 num = numParm;
	}
	int getNum(){
		return num;
	}
	void getInfo(){
		System.out.println(name+" "+ type+" " + price);	
	}
	
	void getInfo(String name,String type,int price){
		System.out.println(name+" "+ type+" " + price);
	}
	void call(int num){
		System.out.println("拨打电话" + num);
	}
	
}

main方法细节：

a.每个类中都可以存在main()方法，但是当执行的时候，会优先查看public的class中是否有main方法。

b.如果没有public 的class，那么会按照文件名优先查找类中的main方法

c.必须定义为public

三.优先原则：对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理。

四.this关键字

含义：代表了当前对象的引用.(可以理解为，当前谁来调用，那么方法中的this就代表谁。)

对于成员变量可以区分出来的场景，this可加也可以不加，实际效果相同。

但对于实现javaBean/POJO类来说，我们建议都加上setXxx,getXxx方法。

this可以加在成员变量的前面也可以加在成员方法的前面。

public class Person {

	
	private String name;
	private int age;
	private int num;
	private String sex;
	
	void setName(String name){
		this.name = name;     //this指当前对象的引用
	}
	String getName(){
		return name;
	}
	
	void setAge(int age){
		this.age = age;
	}
	int getage(){
		return age;
	}
	
	void setNum(int num){
		this.num = num;
	}
	int getNum(){
		return num;
	}
	
	void setSex(String sex){
		this.sex = sex;
	}
	String getSex(){
		return sex;
	}
	void getInfo(String name,int age,int num,String sex){
		System.out.println(name+" "+age+" "+num+" "+sex+" ");
	}
	
	private void study(){
		
	}
	
	
	
	public static void main(String[] args) {
		Person person1 = new Person();
		Person person2 = new Person();
		person1.getInfo("Jim",21,120321,"男");
		person2.getInfo("Ana",20,234432,"女");
	}

}

五.初始化类成员变量的方式

a.在定义成员变量的同时进行赋值。

b.提供外界访问的方法，在方法中进行赋值。

c.通过构造方法进行赋值。

public class DemoClassTest{
	public static void main(String[] args){
		
		//第一种方式:
		//在构造方法执行前进行赋值，并且该类每个实现的对象，都会被初始化为该值.
		//意义: 当我们真的需要一个类的所有对象某些成员变量的值一致的时候。
		Person person = new Person();
		//person.age = 12;  	//error,当age定义为private时会编译出错。
		person.entity = "Japan";
		person.showEntity();
		person.outputAge();
		System.out.println("-----------------");
		//第二种方式
		//构造方法中直接进行赋值.
		//意义：可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么
		Person person1 = new Person(40);
		person1.showEntity();
		person1.outputAge();
		person1.eat();
		System.out.println("-----------------");
		
		//第三种方式
		//通过调用某个设置值的方法进行赋值,在对象创建完成之后
		//意义: 动态的修改成员变量的值.
		Person person2 = new Person();
		person2.showEntity();
		person2.setAge(15);
		person2.outputAge();
		person2.eat();
		System.out.println("-----------------");
		
	}
}

class Person{
		
		//改成员变量就不可被外部访问(外部: 类之外)
		private int age=20;
		static String entity;
		
		//是给成员变量赋值
		
		//优先原则: 对于一个方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.
		
		Person(){
			
		}
		
		Person(int age){
			this.age = age;
		}
		
		
		void setAge(int age){
			this.age = age;
		}
		
		//拿到成员变量的值
		int getAge(){			
			return this.age; 
		}
		
		void eat(){
			System.out.println("eat :"+this.age);
			speak();
		}
		
		void outputAge(){
				System.out.println(this.age);
		}
		
		void speak(){
			System.out.println("speak!");
		}
		
		void showEntity(){
			System.out.println("Entity:"+entity);
		}
		
}

六.static

a.随着类加载而加载

静态方法区中来保存静态成员变量

b.优先于对象创建

Person.className = "java";

c.被类的所有对象共享

静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份。

public class Student{
	
	static String className;
	
	public static void main(String[] args){
		Student student = new Student();
		student.className = "java";		
		System.out.println(new Student().className);
		System.out.println(new Student().className);
	}
	
}

d.可以通过类名来访问也可以通过对象来访问。（效果是一样的）

e.推荐通过类名来访问

f.静态的成员一般称为类相关的成员。

static 修饰符既可以修饰成员变量，也可以修饰成员方法。

g.this变量在静态方法中不可以使用

h.静态方法中只能访问静态成员变量和静态方法。

非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法。非静态虽然可以访问静态方法，但一般建议不这么做。

public class DemoStatic{
	public static void main(String[] args){
		Person person = new Person();
	
		Person.action();			//静态方法可以直接通过类名来访问
		Person.speak();
		
		//person.name="ryan";		//静态成员变量保存在class的静态方法区中，所以每个类中每个对象看到的都是一样的
		System.out.println(new Person().name);
		System.out.println(Person.name);
		
		Person person1 = new Person();
		
		//person.name = "luona";
		System.out.println(Person.name);
		method();
	}
	
	static void method(){
		System.out.println("method");
	}
}

class Person{
	static String name = "diffo";     
	static int age = 20;
	
	 static void speak(){
		System.out.println("speak:"+age);
	}
	
	 static void action(){			//静态方法只能访问静态方法，若speak()不是静态方法，则会编译出错
		speak();
	}
}

七.工具类

全部都是静态的方法。所以可以通过 类名.functionName()方法来访问。

一般的话，都 会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方法。

//工具类: 都是把其中的方法定义为static
public class MathUtil{
	
	//加法
	static int sum(int num1,int num2){
		return num1+num2;
	}
	
	//减法，乘法 
	static int multipli(int num1,int num2){
		return num1*num2;
	}
    private MathUtil(){						//一般对默认构造方法私有化，防止别人使用时习惯性的创建对象来调用方法
		
	}
	
	public static void main(String[] args){
		//System.out.println(MathUtil.sum(2,3));
		
		new User().getResult();

	}
}

class User{
	
	void getResult(){
		System.out.println(MathUtil.sum(2,3)+" "+MathUtil.multipli(2,3));
	}
	
}

package day_07_10_14;
/**
 *给出正方行的一个工具类，可以求正方形的周长和面积，并进行测试
 */
public class UtilTest {

	public static void main(String[] args) {
		Square square  = new Square();
		square.setLengthOfSize(3);
		
		System.out.println(SquareUtil.getSumOfLength(square));
		System.out.print(SquareUtil.getArea(square));

	}

}
//javaBean类
class Square{
	private int lengthOfSize;
	
	void setLengthOfSize(int lengthOfSize){
		this.lengthOfSize = lengthOfSize;
	}
	
	int getLengthOfSize(){
		return lengthOfSize;
	}
}
//正方形工具类
class SquareUtil{
	private SquareUtil(){
		
	}
	
	static int getSumOfLength(Square square){
		return 4*square.getLengthOfSize();
	}
	
	static int getArea(Square square){
		return square.getLengthOfSize()*square.getLengthOfSize();
	}
}