Java 封装、static、final、代码块、object

封装一、封装、类的全限命名 1、封装：

	package包，写在第一行。我们写了n个Demo01.Java
	  类的全限定名：com.easthome.day08.Demo07
	 
	import:
	1、不在同一个包下，需要写类的全限定名来找到某个类
	2、我们可以用import的方式，导入一个包
	3、如果同一个类中，真的要使用不同包下的类，那其中一个需要全限定名
	静态导包。

封装：
电脑里面的软件是公开的，可以使用
电脑里面的属性：Cpu、win10、这些数据，只能看，不能让我们改
如Dog类，里面的成员变量，name、age.在day08的包下可以使用
日记：私人的
汽车的类：
一键启动是公共的，底层的点火设置为私有的。

2、封装类型：

public ：共有的，谁都能用
protected ：受保护的。本包下可以使用，子父类间的调用，用super()
private：私有的，本类中可以使用
默认的: default 本包下可以使用

private：

电脑的属性：可以看（public），不能改(private)
以后属性(成员变量)基本都是private
我们会设置两个public的方法，来获取

public class Demo06 {
	public static void main(String[] args) {
		E e = new E();
		System.out.println("标准版："+e.getName());
		System.out.println("标准版："+e.getAge());
		e.setName("高宇婷");
		e.setAge(20);
		System.out.println(e.getName());
		System.out.println(+e.getAge());
		
	}
}
class E{
	
	private String name = "小高";//成员变量设置为private，要获取get set方法
	private int age = 88;
	
	//private int arr[] = {1,2,4,5,6,7};
	

	public String getName(){
		return this.name;
	}
	
	public int getAge (){
		return this.age;
	}
	
	//修改名字
	public void setName(String name){
		this.name = name;
	}
	//修改年龄
	public void setAge(int age){
		this.age = age;
	}
}`

public：

public 修饰符可以跨类，不加public 是默认类。只能在本类里

public static final String COMPANY_NAME = "小高公司";
public static final String COMPANY_ADDRESS = "北极";
public static final String COMPANY_TYPE = "卖鞋";

二、static

> 1、static：静态、类级别的。static修饰的，存在方法区
> 天庭造人，一个个对象。天庭中的成员变量叫static变量
> Dog.class 文件--> 加载到内存(类信息)
> 2、static 成员变量的特点：对象创建时就存在了对象中。
> 如果我们想拿到dog的name，需要先创建一个dog对象。 	通过dog.name来获取


 但是static修饰的变量。是类级别，不用对象存在，它存于方法区
	直接用类名去调用，如：Dog.count
	类被加载时创建
	
	**静态方法中不能写this**
	
	**静态方法中不能直接调用非静态的方法，需要new一个对象**
	非静态方法中可以调用静态方法
 static 常用在工具类、工厂类中国
	如Math,自身不需要成员变量（名字、年龄），只是提供功能。
	工厂类：也不需要成员变量、普通方法。就是帮你提供

	public static void main(String[] args) {
		System.out.println(Dog.count);
		Dog d1 = new Dog();
		//The static field(成员变量，属性) Dog.count should be accessed in a static way
		d1.count++;
		d1.count1++;
		System.out.println(d1.count);
		System.out.println("count1,"+d1.count1);
		
		Dog.count++;
		Dog.count1++;
		System.out.println("count"+Dog.count);
		System.out.println("count1,"+Dog.count1);
		
		Dog d2 = new Dog();
		d2.count = 50;
		System.out.println(d2.count);
		
		Dog.count++;
		System.out.println(Dog.count);	
		
		
//		Demo02 d = new Demo02();
//		d.test();
	}
	
	
	public void test(){
		System.out.println("ggg");
	}

三、代码块 1、局部代码块

静态走完之后，走构造方法。在走子类的构造方法时，会调用一个父类的super
Object 万物皆对象

调用父类方法时：先走父类静态方法，然后走子类的静态方法
然后走父类的代码块，再走子类的代码块。因为在构造方法之前先走的是代码块。
所以接下来走的是子类的构造方法。最后走的是父类的构造方法

public static void main(String[] args) {
		A a = new A();
		A a1 = new A("aa",20);
		Object o = new Object();
		a.test();
	}
}
//父类
class c{
	public void test(){}
	public final void test1(){}
}
//子类
class B extends c{
	int xx;
	//静态方法
	static{
		System.out.println("B的静态方法");
	}
	
	public B(){
		//super(); 默认的方法
		System.out.println("3、B的无参构造");
	}
	public B(int xx){
		this.xx = xx;
		System.out.println("6、B的有参构造");
		
	}
	//子类重写父类的test1方法，当父类的方法中加上final，就表示不能再被调用了
	//public void test1(){System.out.println("子类重写");}
}

class A extends B{
	static int count;
	String name;
	int age;
	
	static{
		System.out.println("A的静态代码块----------------");
		count  = 9;
		//加载一个文件。
	}
	public A(){
		System.out.println("5、调用无参的构造方法");
		
	}
	public A(String name ,int age){
		this.name = name;
		this.age = age;
		System.out.println("8、调用有参的构造方法");
	}
	
	
	{
		System.out.println("4、要调用构造方法了");
//		System.out.println("1");
//		System.out.println("2");
//		System.out.println("3");
//		System.out.println("4");
	}

四、final 1、final：终结者

final:最终的
1. final可以用来修饰的结构：类、方法、变量
2. final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类
3. final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass();
4. final 用来修饰变量：此时的"变量"就称为是一个常量
4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
4.2 final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
static final 用来修饰属性：全局常量

我们之前说的内存管理，对于不同的jdk版本，会有微调
如jdk7开始常量池移到了堆中
jdk8开始，方法区没了，常量池

final关键字不能用来修饰抽象类和接口。
因为抽象类是需要被继承的，用final修饰没有意义。
如果一个普通类实现接口，要实现接口中所有的方法。如果用final修饰也同样没有意义

抽象方法同样不能使用private、final、static来修饰，这些都是和重写相违背的

public static void main(String[] args) {
		System.out.println(Constants.COMPANY_ADDRESS);
	}
}
class D{
	String name;
	//final 在定义时直接赋值,如果不直接赋值时，另一种方法是在构造方法中赋值
	final int age = 3;
	final int b;
//	final int age = 9;//在定义的时候直接赋值
//	final int a;
	
	static final int COUNT = 9;//常量，通常设置为常量，常量名是大写的
	static final int NUM = 3;//常量
	//如果成员变量用的是final修饰，那么构造方法中是不需要传参数的
	public D(){
		b=10;//final 修饰的成员变量。一种是在定义时直接赋值。另一种方案是在构造方法中赋值
	}
	
	public void test(){
		this.name = "vv";
		//this.age = 10;此时的age已经被终结了，不能再使用
		final int x = 9;
	}
	public void aa(){
		
	}

五、Object

Object 万物皆对象
Object是顶级父类。

1、父类提取公共部（Object方法） info（）方法

info();–>输出成员变量的。(标准方法：toString())
toString 被用来输出实例对象的信息，但是Object默认输出的是类的全限定名@hashcode
通常我们需要重写toString();
子类没有重写父类的toString之前，会调用Object自带的toString方法。重写后，调用子类自己的toString方法();
我们可以自动生成构造方法和toString方法

public static void main(String[] args) {
		F f = new F();
		f.name = "张三";
		f.age = 5;
		//toSring是已经写好的输出实例对象信息的方法。可以直接使用
		System.out.println(f.toString());
		System.out.println(f);//输出f对象，默认是在调用f.toString();
		//小狗、小猫、小猪-->Animal
	}
}
class F{
	String name ;
	int age;
	
	@Override
	public String toString() {
		return "F [name=" + name + ", age=" + age + "]";
	}
	
	
	
//	public String toString1(){
//		return "name="+name+"age="+age;
//		
//	}

equals（）方法

equals 比较是否相等 * * ==：

对于基本数据类型，直接判断值是否相等 * 如果对于引用数据类型，比较的是地址。
而开发时，通常比较的并不是地址，如学生会和教务处的学生，我们只想比较学生的信息 * 此时用 == 就很不合适了
Object 提供了一个equals方法，用来判断两个对象是否相等（替代，而改为自己定义相等的规则）
而Object类的equals的方法里面的是==，相当于没干活，我们通常会重写equals方法

public static void main(String[] args) {
		G g = new G("mm",5);
		System.out.println(g);
		System.out.println(3 ==6);
		G g1 = new G("mm",5);
		System.out.println("两个对象地址是否相同"+(g == g1));
		System.out.println("两个对象信息是否相同"+g.equals(g1));
	}
}
class G{
	String name;
	int age;
	@Override
	public String toString() {
		return "G [name=" + name + ", age=" + age + "]";
	}
	public G(){}
	public G(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)//如果俩人恒等
			return true;
		if (obj == null)//如果传入的是null返回false
			return false;
		if (getClass() != obj.getClass())//如果不是同一类型返回false
			return false;
		
		
		G other = (G) obj;
		//如果年龄不相同
		if (age != other.age)
			return false;
		//如果姓名不相同就返回false
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

toString 是输出对象信息，子类重写父类信息
equals：如果是基本类型的话，判断的是两个值是否相等。如果是引用类型的话，判断的是两个地址空间是否相等

六、包装类包装类

包装类：
int–>Integer
double–>Double
byte–>Byte
short–>Short
float–>Float
long–>Long
boolean–>Boolean
char–>Character

自动拆封箱

Java处处有优化、Integer、String

public static void main(String[] args) {
		//Demo01 d= new Demo01();
		Object d = new Demo01();//类似于int-->double
		test1(d);
		
//		Integer a = new Integer(3); 可以不这么写,类似于String
		Integer a = 128;//128是个小int，Java会自动把这个小int封装成一个对象
		int b = a;//a是一个Integer类型 的对象，Java会自动把这个对象拆箱成小int
		
		Integer i = 4;//Java把int类型的4自动封装成一个Integer对象
		int j = i;//i是一个Integer类型的对象，Java会自动把这个对象拆分成int类型
		
		test1(a);
		Integer a1 = 128;
		System.out.println(a==a1);//Integer定义两个变量的值小于128的时候，判断相等时是相等的，如果大于等于128是false

Integer有些自带的方法

如果用户传数据。我们用Integer定义的变量可以给设置为null
如果用int定义的变量，我们没法赋值，0也是值。不赋值就不能使用
Integer有个方法，可以把字符串类型的数字转为整数。前提必须是字符串类型的数字

Integer x = null;
		x = Integer.valueOf("444");//把444转为整数，用Integer或int都可以
		System.out.println(x);
		a = Integer.parseInt("123");
		System.out.println(a);
		System.out.println(Integer.MAX_VALUE);
		
		Integer y = Integer.valueOf("5",8);//将字符串类型的数字转换成了int型
		System.out.println("y="+y);
		y = Integer.BYTES;//常量4
		System.out.println(y);
		y = Integer.MAX_VALUE;
		System.out.println("最大值"+y);
		y = Integer.MIN_VALUE;
		System.out.println("最小值"+y);
		y = Integer.SIZE;
		System.out.println(y);//int 类型是32位
		
		System.out.println(Double.BYTES);//byte类型是位
		System.out.println(Double.MIN_EXPONENT);
		System.out.println(Double.MIN_NORMAL);
		System.out.println(Double.NaN);
		System.out.println(Double.class);
		System.out.println(Double.compare(1.6, 4.5));
		System.out.println(Double.parseDouble("456"));

Java 封装、static、final、代码块、object

Java相关栏目本月热门文章