[小程序]Http网络请求

Day16

1.抽象类及抽象方法的使用

//抽象类：使用abstract修饰       
public abstract class Person {//父类

	private String name;
	private char sex;
	private int age;
	
	//无参构造，有参构造，get、set方法，省略
	
	//抽象方法：没有代码块，使用abstract修饰的方法，交给非抽象的子类去实现
	//注意：抽象方法必须在抽象类中
	public abstract void eat();
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}

public abstract class Chinese extends Person{

	private String id;
	
	public Chinese() {
	}

	public Chinese(String name, char sex, int age, String id) {
		super(name, sex, age);
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	 
	public abstract void hobbies();
	
}

public class SiChuan extends Chinese{
	
	public SiChuan() {
	}
	
	public SiChuan(String name,char sex,int age,String id){
		super(name, sex, age, id);
	}

	@Override
	public void hobbies() {
		System.out.println(super.getName() + "喜欢打麻将、炸金花");
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃火锅、串串香");
	}

}

public class Japanese extends Person{

	private String yearNum;
	
	public Japanese() {
	}
	
	public Japanese(String name, char sex, int age, String yearNum) {
		super(name, sex, age);
		this.yearNum = yearNum;
	}

	public String getYearNum() {
		return yearNum;
	}

	public void setYearNum(String yearNum) {
		this.yearNum = yearNum;
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃马赛克");
	}

}

//测试类
public class Test01 {
	public static void main(String[] args) {
		
		Japanese j = new Japanese("波多野结衣", '女', 18, "令和");
		j.eat();
		j.sleep();
		
		System.out.println("-----------------------");
		
		SiChuan sc = new SiChuan("小彭", '男', 21, "1234567890");
		sc.eat();
		sc.hobbies();
		sc.sleep();
		
		System.out.println("-----------------------");
		
		GuangDong gd = new GuangDong("李嘉诚", '男', 97, "0987654321");
		gd.eat();
		gd.hobbies();
		gd.sleep();
	}
}

1.1抽象类的特征

1.2抽象类的细节

2.抽象类及抽象方法的深入

面试题

public class Test02 {
	public static void main(String[] args) {
		
		Person p = new Person("弗罗兹·甘地",'男',23) {//底层是创建匿名类内类，不是抽象类
			
			@Override
			public void eat() {
				System.out.println(super.getName() + "吃咖喱");
			}
		};
		p.eat();
		
	}
}

匿名类内类内存理解图1：

3.接口的使用

//实体类
public class Student {
	
	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;

	//无参构造，有参构造，get、set方法，省略

	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id + "]";
	}
}

//学生管理系统的接口  (大纲)
public interface IStudentManagerSystem {
	
	//静态常量
	//默认使用public static final修饰
	int NAME = 1;
	int SEX = 2;
	int AGE = 3;
	int CLASS_ID = 4;
	int ID = 5;

	//抽象方法  (大纲)
	//默认使用public abstract修饰
	public void add(Student stu);//添加
	
	public void delete(String classId,String id);//删除
	
	public void update(String classId,String id,int type,Object val);//更新
	
	public Student getStu(String classId,String id);//查询
	
	//静态方法
	public static void method01(){
		System.out.println("IStudentManagerSystem接口中的静态方法");
	}
	
	//默认方法
	//默认使用public修饰
	default void method02(){
		System.out.println("IStudentManagerSystem接口中的默认方法");
	}
}

//学生管理系统的实现类
public class StudentManagerSystemImpl implements IStudentManagerSystem{

	@Override
	public void add(Student stu) {
	}

	@Override
	public void delete(String classId, String id) {
	}

	@Override
	public void update(String classId, String id, int type, Object val) {
	}

	@Override
	public Student getStu(String classId, String id) {
		return null;
	}

}

//测试类
public class Test01 {
	public static void main(String[] args) {
		
		StudentManagerSystemImpl sms = new StudentManagerSystemImpl();
		
		//调用实现类实现的方法
		sms.add(new Student());
		//调用默认方法
		sms.method02();
		//调用静态方法
		IStudentManagerSystem.method01();
	}
}

3.1定义格式

interface 接口名称{

  // 抽象方法

}

3.2接口的实现

实现接口的格式

//接口的实现：
class 类名 implements 接口1,接口2,接口3...{

}

3.2.1 类实现接口的要求和意义

4.接口的深入

面试题

public interface I1 {

	public void i1Method();
}

public interface I2 {

	public void i2Method();
}

public interface I3 extends I4,I5{

	public void i3Method();
}

public interface I4 {

	public void i4Method();
}

public interface I5 {

	public void i5Method();
}

public class B {

}

public class A extends B implements I1,I2,I3{//A 继承 B 实现I1，I2，I3接口

	@Override
	public void i2Method() {
	}

	@Override
	public void i1Method() {
	}

	@Override
	public void i4Method() {
	}

	@Override
	public void i5Method() {
	}

	@Override
	public void i3Method() {
	}

}

5.多态

5.1类的多态

//交通工具
public abstract class Vehicles {

	private int count;//座位数
	private String color;//颜色
	
	public Vehicles() {
	}
	
	public Vehicles(int count, String color) {
		this.count = count;
		this.color = color;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public abstract void open();
	
	public abstract void close();
}

public class Bick extends Vehicles{
	
	public Bick() {
	}
	
	public Bick(int count,String color){
		super(count, color);
	}
	
	public void open(){
		System.out.println("自行车：握好扶手，踩下脚踏板");
	}
	
	public void close(){
		System.out.println("自行车：捏手刹");
	}
}

public class Car extends Vehicles{
	
	public Car() {
	}
	
	public Car(int count,String color){
		super(count, color);
	}

	public void open(){
		System.out.println("小汽车：一键启动，挂D档，踩下油门");
	}
	
	public void close(){
		System.out.println("小汽车：踩刹车，挂P档，熄火");
	}
}

public class Plane extends Vehicles{

	@Override
	public void open() {
		System.out.println("飞机：踩油门");
	}

	@Override
	public void close() {
		System.out.println("飞机：达到P城，跳伞");
	}

}

public class Teacher {

	public void start(Vehicles v){
		v.open();
	}
	
	public void stop(Vehicles v){
		v.close();
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		Teacher t = new Teacher();
		
		//类的多态：子类对象指向父类引用
		//理解：父类引用中存储的是子类对象在堆中开辟的内存地址
		Vehicles v = new Plane();
		
		t.start(v);
		System.out.println("欣赏沿途的风景");
		t.stop(v);
		 
	}
}

5.2接口的多态

public interface IUSB {

	public void use();
}

public class Mouse implements IUSB{

	@Override
	public void use() {
		System.out.println("鼠标：左点点、右点点");
	}
}

public class KeyBoard implements IUSB{

	@Override
	public void use() {
		System.out.println("键盘：输入数据");
	}

}

//电脑类
public class Computer {

	//连接
	public void connection(IUSB usb){
		usb.use();
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		Computer computer = new Computer();
		
		//接口的多态：实现类对象指向接口的引用
		//理解：接口的引用存储的是实现类对象在堆中开辟的地址
		IUSB usb = new KeyBoard();
		
		computer.connection(usb);
	}
}

5.3多态的形式

5.4多态的前提

6.对象转型

6.1向上转型

public class Father {

	String fatherAttr = "父类属性";
	
	public void fatherMethod(){
		System.out.println("父类方法");
	}
	
	public void fun(){
		System.out.println("父类方法");
	}
}

public class Son extends Father{

	String sonAttr = "子类属性";
	
	public void sonMethod(){
		System.out.println("子类方法");
	}
	
	@Override
	public void fun() {
		System.out.println("子类重写父类的方法");
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		//向上转型
		Father father = new Son();
		
		System.out.println(father.fatherAttr);
		father.fatherMethod();
		
		father.fun();
	}
}

6.2向下转型

public class Test01 {
	public static void main(String[] args) {
		
		//向上转型
		Animal an = new Cat();
		
		//向下转型
		if(an instanceof Dog){//判断引用an中指向的对象是否是Dog类型
			Dog dog = (Dog) an;
			dog.shout();
		}else if(an instanceof Cat){//判断引用an中指向的对象是否是Cat类型
			Cat cat = (Cat) an;
			cat.eat();
		}
		
	}
}

6.3对象转型的应用场景

public class MyString {

	private char[] value;
	
	public MyString(String original) {
		//"abc"
		//['a','b','c']
		value = original.toCharArray();//将字符串转换为字符数组
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		if(obj instanceof MyString){
			MyString my = (MyString) obj;
			
			char[] v1 = this.value;
			char[] v2 = my.value;
			
			//比较字符长度
			if(v1.length != v2.length){
				return false;
			}
			
			for (int i = 0; i < v1.length; i++) {
				//比较字符的Unicode码是否相同
				if(v1[i] != v2[i]){
					return false;
				}
			}
			return true;
		}
		return false;
	}
	
	@Override
	public String toString() {
		return String.valueOf(value);//将字符数组转为字符串
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		String str1 = new String("abc");
		
		System.out.println(str1.equals(new Student()));//false
		
		
		System.out.println("-------------------------------");
		
		MyString m1 = new MyString("abc");
		
		System.out.println(m1.equals(new Student()));//false
		
	}
}

7.内部类

public interface I1 {

	//接口内部类
	class Inner{
	}
}

//外部类
public class Outter {

	//成员内部类
	class Inner01{
	}
	
	//静态内部类
	static class Inner02{
	}
	
	public void method(){
		
		//局部内部类
		class Inner03{
		}
		
	}	
	
}

7.1成员内部类

//外部类
public class Outter {
	
	private 		String str1 = "外部类属性1";
					String str2 = "外部类属性2";
	protected 		String str3 = "外部类属性3";
	public 			String str4 = "外部类属性4";
	final 			String str5 = "外部类属性5";
	static 			String str6 = "外部类属性6";
	static final 	String str7 = "外部类属性7";

	//成员内部类
	class Inner{
		
		String str1 = "内部类属性";
		
		public void innerMethod(){
			System.out.println("成员内部类的方法");
			System.out.println(str1);//this.str1
			System.out.println(Outter.this.str1);
			System.out.println(str2);//Outter.this.str2
			System.out.println(str3);//Outter.this.str3
			System.out.println(str4);//Outter.this.str4
			System.out.println(str5);//Outter.this.str5
			System.out.println(str6);//Outter.str6
			System.out.println(str7);//Outter.str7
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建成员内部类的对象
		Inner inner = new Outter().new Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

7.3静态内部类

//外部类
public class Outter {
	
	static 			String str1 = "外部类属性1";
	static final 	String str2 = "外部类属性2";

	//静态内部类
	static class Inner{
		
		
		public void innerMethod(){
			System.out.println("静态内部类的方法");
			System.out.println(str1);//Outter.str1
			System.out.println(str2);//Outter.str2
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建静态内部类的对象
		 Inner inner = new Outter.Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

7.4接口内部类

//外部接口
public interface Outter {
	
	//接口内部类
	//默认使用public static修饰
	class Inner{
		
		public void innerMethod(){
			System.out.println("接口内部类的方法");
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建静态内部类的对象
		 Inner inner = new Outter.Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

7.5局部内部类

//外部类
public class Outter {
	
	public void method(){
		
		//局部内部类
		class Inner{
			public void innerMethod(){
				System.out.println("局部内部类的方法");
			}
		}
		
		//创建局部内部类对象
		Inner inner = new Inner();
		//调用方法
		inner.innerMethod();
		
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		Outter outter = new Outter();
		outter.method();
	}
}

7.5.1局部内部类的面试题

//外部类
public class Outter {
	
	public Object method(){
		
		int num = 100;
		
		//局部内部类
		class Inner{
			@Override
			public String toString(){
				return "局部内部类的方法 -- " + num;
			}
		}
		
		Object obj = new Inner();
		
		return obj;
	}
	
}

public class Test01 {

	public static void main(String[] args) {
		
		Outter out = new Outter();
		
		Object obj = out.method();
		System.out.println(obj.toString());//调用子类重写的toString
	}
}

局部内部类理解图：

7.6匿名内部类

new 父类名或者接口名(){

      // 方法重写

      @Override 

      public void method() {

      // 执行语句

    }

};

public abstract class A {

	public abstract void method();
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建匿名内部类的对象
		//1.底层创建一个匿名类(Test01$1.class)，继承A类，重写method方法
		//2.创建匿名子类的对象
		//3.赋值给父类的引用（类的多态）
		A a = new A() {
			@Override
			public void method() {
			}
		};
		
		a.method();
		
	}
}

7.6.1匿名内部类(接口)

public interface I1 {

	public void method();
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建匿名内部类的对象
		//1.底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法
		//2.创建匿名实现类的对象
		//3.赋值给接口的引用（接口的多态）
		I1 i1 = new I1() {
			@Override
			public void method() {
				
			}
		};
		
		i1.method();
	}
}

总结