内部类的四种情况，object类的5个方法

常用类

1. 接口：interface 是一种规范，表示一种能力

2. has-a的关系

3. 接口中成员特点

   属性：public static final

   方法：public abstract

4. 作用：约束子类行为，用作引用，不能被new 污垢发哦方法

5. 类单继承，多实现， 接口之间多继承

6. 接口分离原则：接口中的方法尽可能少，放同类型/同方向的方法

7. 重要：接口和抽象类的区别？

   常见：都不能被new，抽象类有构造方法的，接口无构造方法

   成员：接口—属性public static final

   ​ 方法public abstract

   ​ 抽象类----可以有任意的方法

   继承：类是单继承的，接口是多实现的。

内容

• 内部类 4种使用方式
• Object类
• String类
• BigDecimal
• 包装类
• 日期，时间类

内部类

​ 内部类：在一个类的内部，有声明了一个类，成为内部类，外面的叫外部类

类型

• 成员内部类：

  • 【说明】：成员内部类中不能声明static成员

  //内部类
  	public class Outer {
  		//属性
  		private String name="张三";
  		private int age;
  		public void test() {
  			System.out.println("外部类的test()");
  		}
  		public void test1() {
  			
  			Inner inner = new Inner();
  			System.out.println(inner.address);
  		}
  		
  		//成员内部类
  		class Inner{
  			//内部类成员
  			private String address="辽宁省大连市";
  			private String phone="0123-7777777";
  			private String name="李四";
  			//方法
  			public void show() {
  				//可以访问外部类的成员
  				System.out.println(Outer.this.name);
  				System.out.println(Outer.this.age);
  				Outer.this.test();
  				//访问你内部成员
  				System.out.println(this.address);
  				System.out.println(this.phone);
  				System.out.println(this.name);
  			}
  		}
  }
  
  
  //调用类
  public class TestOuter {
  
  	public static void main(String[] args) {
  		// TODO Auto-generated method stub
  		//创建外部类对象
  		Outer outer=new Outer();
  		outer.test();
  		
  		//创建内部类对象,如果访问内部类成员，那么必须创建内部类对象。
  		//方式1
  		Inner inner=outer.new Inner();
  		
  		//方式2
  		Inner inner1=new Outer().new Inner();
  		
  		inner.show();
  		inner1.show();
  	}
  
  }
  

• 静态内部类

  静态内部类与成员内部类的区别

  • 在静态内部类中可以声明静态成员
  • 在静态内部类中访问外部类的实例成员是，不能直接访问，必须创建外部类对象通过对象访问
  • 创建内部类方式不同
    • 成员内部类：Inner inner=new Outer().Inner();
    • 静态内部类：Outer.Inner inner=new Outer.Inner();

  
  public class Outer {
  	private String name;
  	private int age;
  	public void test() {
  		System.out.println("外部类的test()");
  	}
  	//静态内部类
  	static class Inner{
  		//成员
  		private String address="辽宁省大连市";
  		private String phone="0123-7777777";
  		//可以生命静态成员
  		private static int count=100;
  		public void show() {
  			//静态成员不能直接访问实例成员，可以直接访静态成员
  			//实例成员可以直接访问实例成员，也可以直接访问静态成员。
  			//如果要访问外部类成员。---new
  			
  			Outer outer=new Outer();
  			outer.name="张三";
  			outer.age=20;
  			System.out.println(outer.name);
  			System.out.println(outer.age);
  			System.out.println(this.address);
  			System.out.println(phone);
  			System.out.println(Inner.count);
  		}
  	}
  }
  //test类
  
  public class Test {
  
  	public static void main(String[] args) {
  		// TODO Auto-generated method stub
  		Outer outer=new Outer();
  		outer.test();//访问外部类成员
  		
  		//访问静态内部类成员
  		Outer.Inner inner=new Outer.Inner();
  		inner.show();//访问内部类成员
  		
  	}
  
  }
  

• 局部内部类

  
  public class Outer {
  	private String name="张三";
  	private int age=20;
  	public void show(final int i) {
  		//局部变量i在复制后就不能更改
  		//声明局部变量
  		String address="辽宁大连";
  		//局部内部类
  		class Inner{
  			//局部内部类的属性
  			private String phone="022-7777777";
  			private String email="sf65s1@qq.com";
  			//private static final int count=100;
  			public void show2() {
  				//访问外部类的属性
  				System.out.println(Outer.this.name);
  				System.out.println(Outer.this.age);
  				//内部类属性
  				System.out.println(this.phone);
  				System.out.println(email);
  				//在jdk1.7中，局部内部访问的局部变量必须是final修饰的
  				//在jdk1.8开始，局部变量默认具有final属性
  				//address="撒打发二";
  				System.out.println(address);
  			}
  		}
  		//创建局部内部类对象----一定要在内部类的有效作用域内创建
  		Inner inner=new Inner();
  		inner.show2();
  	}
  }
  //test类
  

• 匿名内部类

  public interface Usb {
  	void service();
  }
  //测试类
  
  public class TestUsb {
  
  	public static void main(String[] args) {
  		// TODO Auto-generated method stub
  		Usb mouse=new Usb() {
  			//{}里的就是匿名内部类，此匿名内部类默认是Usb接口的实现类
  			@Override
  			public void service() {
  				// TODO Auto-generated method stub
  				System.out.println("我是Usb鼠标");
  				
  			}
  			
  		};
  		Usb keyBord=new Usb() {
  			@Override
  			public void service() {
  				// TODO Auto-generated method stub
  				System.out.println("Usb键盘");
  			}		
  		};
  		mouse.service();
  	}
  
  }
  
  

  Object类

  在java继承结构中Object了ishi所有类的默认父类，新建一个类周，默认继承Object

  java默认导入lang包，Object,String在此包下

  api：application interfac–应用程序接口–系统类

  getClass()

  对象.getClass() 返回的类型是Class，代表对象的实际类型。

  hashCode()

  返回的是地址的，字符串的，整型值的十进制整数值，是java根据哈希算法计算出的一个值

  【说明】：同一个地址，字符串，整数型的哈希值是固定的

  ​ 相同对象返回相同的哈希值，确保不同对象返回不同的哈希值—需要重写hashCode();

  toString()

  ​ String类重写了Object中的toString()

  ​ toString()以字符串形式返回值

  ​ 当new出了一个对象后，默认

  equals()

  ​ ==比较的是引用类型的地址是否相同

  如果比较引用类型的值是否相同，使用equals()

  finalize() —垃圾回收

  回收当前对象

  垃圾对象：当对象的地址没有被应用后，JVM视这个对象为垃圾对象

  垃圾回收：JVM有GC，垃圾回收器，按照某种算法，在某个时间点会回收垃圾对象，释放内存

  【垃圾回收有两种】

  • 自动垃圾回收：JVM内存不足时，就回收所有对象
  • 手动垃圾回收：System.gc()告知JVM回收垃圾对象

  ---

  总结

  1. 作业题 完成question8-16，17

     ​ 二分法查找

  2. 内部类：4种方式

  3. Object类

     1. hashCode()
     2. toString()
     3. equals()

  ---

  作业

  1. 完成讲解的作业
  2. 梳理技能点，完成课堂案例 熟练完成