折纸的不归路(12)

一.包装类

装饰者模式

String —> 不可变的字符串
“a”+“b”+“c” --> “ab”+“c” --> “abc”

对基本数据类型包装成为引用数据类型
为什么要包装？
Java中编程单元是类 —> 引用类型
如何用引用类型MyInt，包装一下基本类型。
基本数据存在的意义：
简单的四则运算
存储方便

static 补充使用

在import里静态导入
如 ： import static java.lang.Math.*;
之前调用静态变量PI：Math.PI
静态导入之后调用方法改变：直接使用PI

二.equals 和 == 号

== 等号左右两侧为引用类型，对比的是地址值
equals方法属于Object，每个类都有，提供重写
默认的equlas方法的判断逻辑和==是一样的，我们可以根据自己的需求去重写equals判断逻辑
1、判断地址是否相同
2、判断类型是否相同
3、提出自己的判断规则

equals测试

package com.briup.day10;

import com.briup.day06.Student;
import com.briup.day08.Address;

/**
 * 测试等号和equals
 * @author mastercgx
 *
 */
public class EqualsTest {
	public static void main(String[] args) {
		String s1 = "hello";
		String s2 = "hello";
		String s3 = new String("hello");
		String s4 = new String("hello");
		System.out.println(s3.equals(s4));
		
		Address add1 = new Address("中国", "江苏", "苏州");
		Address add2 = new Address("中国", "江苏", "苏州");
		Student stu1 = new Student("tom",20,"男",add1);
		Student stu2 = new Student("tom",20,"男",add2);
		System.out.println(stu1 == stu2); //false
		System.out.println(stu1.equals(stu2));//false
		System.out.println(stu1);
		System.out.println(stu2);
		
	}
}

toString() 方法
当我们输出对象的时候，会默认输出toString方法的返回值，Object的toString()方法提供重写

默认的toString()方法会输出该对象的全限类名@十六位的哈希码的地址值

三.内部类

public class Computer{
	int year;
	class Mouse{
		int year;

	}
	class Keyboard{
		int count;
	}
}

定义

在类的内部进行类的声明和使用

讨论的重点

外部类和内部类之间成员的互相调用
内部类的实例化方式
了解内部类的实际的应用场景

分类

静态内部类

1、静态内部类中可以直接访问外部类的静态成员，如果要访问外部类的实例成员，需要通过外部类的实例去访问
2、静态内部类的实例化方式
A.B a = new A.B();
3、静态内部类中可以定义静态成员，也可以定义实例成员
4、可以通过类名直接调用静态内部类中的静态成员

实例内部类

1、实例内部类的实例化方式要依靠外部类的实例来创建
A.C c = new A().new C();
相当于
A a = new A(); A.C c = a.new C();
2、实例内部类中不能够定义静态成员
3、如果实例内部类C中和外部类A中有同名的参数，则
就近原则 this.ai 代表C的
A.this.ai 代表A的
4、实例内部类中可以访问到外部类的所有成员
5、每一个实例内部类的实例都只对应一个外部类的实例，一个外部类的实例可以对应多个内部类的实例

局部内部类

1、局部内部类不能够使用权限修饰符（public、private、protected）以及static
2、局部内部类中不可以定义静态成员
3、局部内部类中可以访问到外部类的所有成员，可以访问到外部类的final修饰的变量
4、局部内部类的作用范围在当前方法内，如果要使用必须声明在类定义之下，外部类无法创建局部内部类的实例

匿名内部类

可能是在实际应用中接触最多的一个内部类
1、匿名内部类的使用方式，new 接口/抽象类(){ 实现其中未实现的方法 }
2、匿名内部类是唯一一个没有构造器的类
3、匿名内部类不可以拥有静态成员
4、可以访问外部类的所有成员
5、一般用作放在方法的参数中，只使用一次的那种

内部类相关测试

package com.briup.day10;
import java.util.Comparator;
import java.util.TreeSet;
import com.briup.day06.Student;
import com.briup.day09.Fish;
import com.briup.day09.Food;
public class InnerClass {
	public static void main(String[] args) {
		A a = new A();
		a.readB();
		//B是静态内部类
		A.B b = new A.B();//静态内部类的实例方式	
		b.showB();
		//通过完整的类名来访问内部类中的静态成员
		A.B.showSb();
		//C是实例内部类
		//A.C c= new A().new C();
		A.C c= a.new C();
		c.showC();
		A.D d = a.new D();
		//E和F是局部内部类
		a.AshowE();
	}
}
class A{	 //外部类/外围类
	int ai = 10;
	static int asi = 20;
	final static String sa = "a final String";
	public void readB() {
		B b = new B(); //外部类使用内部类直接new即可
		b.showB();
		B.showSb();//外部类可以直接使用内部类的类名调用静态的成员
	}
	public void readC() {
		C c = new C();
		c.showC();//外部类只能通过实例内部类的对象去访问实例内部类的成员
	}
	static class B{ //静态内部类
		int bi;
		static int bsi;
		//构造器
		public B() {
			System.out.println("静态内部类B的构造器");
		}
		public void showB() {
			System.out.println(new A().ai);
			System.out.println(asi);
		}
		public static void showSb() {
			System.out.println(new A().ai);
			System.out.println(asi);
		}		
	}	
	class C{  //实例内部类
		int ci = 20;
		int ai = 30;
		//static csi = 30;
		public void showC() {
			System.out.println("====showc=====");
			System.out.println("----"+A.this.ai);
			System.out.println(asi);
			System.out.println(sa);
		}
//		public static void showSc() {
//			
//		}	
	}
	class D implements Food {
		@Override
		public void whatDo() {
			// TODO Auto-generated method stub
		}
		@Override
		public void eat() {
			// TODO Auto-generated method stub
		}
	}
	public void AshowE() {		
		final String s = "hello";
		//执行一下食物的eat方法
		class E { //局部内部类
			int ei;
			//static int esi;
			public void showE() {
				class F{
					public void showF() {
						System.out.println("F 输出");
					}
				}
				F f = new F();
				f.showF();
				System.out.println("=======");
				System.out.println(ei);
				System.out.println(s);
				System.out.println(ai);
				System.out.println(asi);
				System.out.println(sa);
				readC();
			}
//			public static void showSE(){
//				
//			}
		}
		E e = new E();
		e.ei = 20;
		e.showE();
	}
	//匿名内部类的使用
	//自使用
	//new 接口的时候，并不是产生了一个接口的实例
	//而是产生了一个匿名的该接口的实现类的实例
	Food fish = new Fish();
	Food food = new Food() {		
		@Override
		public void whatDo() {
			// TODO Auto-generated method stub			
		}		
		@Override
		public void eat() {
			// TODO Auto-generated method stub			
		}
	};
	//经常使用
	//集合 TreeSet ，具有排序功能，按什么排序？
	//实例内部类的例子
	class MC implements Comparator<Integer>{
		@Override
		public int compare(Integer o1, Integer o2) {
			return o1-o2;
		}		
	}
	MC mc = new MC();
	TreeSet<Integer> ts = new TreeSet<Integer>(mc);
	//匿名内部类
	TreeSet<Integer> ts1 = new TreeSet<Integer>(new Comparator<Integer>() {
		@Override
		public int compare(Integer o1, Integer o2) {
			return o2-o1;
		}
	});
	TreeSet<Student> ts2 = new TreeSet<Student>(new Comparator<Student>() {
		@Override
		public int compare(Student o1, Student o2) {
			//按名字来排序
			return o1.getName().compareTo(o2.getName());
		}
	});
	Shape shape = new Shape() {
		int si;
		//static int ssi;
		public void showShape() {
		}
//		public static void showSShape() {
//			
//		}
		@Override
		public String getType() {
			// TODO Auto-generated method stub
			return null;
		}
		@Override
		public double getPerimeter() {
			// TODO Auto-generated method stub
			return 0;
		}
	};
}

四.心得

今天学习的内容也比较好理解,内部类给我的直观感觉就是不断套娃禁止套娃 所以多余的时间还是用来看之前的内容了,现在对多态相关也有了更深层次的认识,也深刻理解了"编译看左边,运行看右边"这句话.明天继续加油!