2021-02-23

Object类

• Object类的主要特点是可以解决参数同一问题，也就是说Object类可以接收所有数据类型（Object类是所有类的父类）

class Person {
}

public class Demo {
    public static void main(String[] args) {
        Object obj =new Person();   //向上转型
        if(obj instanceof Person){
            Person per=(Person) obj;  //向下转型
            System.out.println("Person对象向下转型执行完毕");
        }
    }
}

• 获取对象信息：toString()

class Person {
}

public class Demo {
    public static void main(String[] args) {
        Person per =new Person();
        System.out.println(per);   //获取的是地址信息
        System.out.println(per.toString());   //Object类继承而来
    }
}

• 覆写toString方法

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {   //覆写toString方法
        return "姓名:+" + this.name + ",年龄:" + this.age;
    }
}

public class Demo {
    public static void main(String[] args) {
        Person per =new Person("张三",18);
        System.out.println(per);
    }
}

• 对象比较：equals()

抽象类（abstract关键字）

• 抽象类的基本定义：对子类中覆写方法进行约定
• 抽象类使用原则：

1.抽象类必须提供有子类
2.抽象类的子类（不是抽象类），一定要覆写抽象类中的全部方法
3.抽象类的实例化可利用对象多态性通过向上转型的方式完成

abstract class Message {   //定义抽象类
    private String type;

    public abstract String getConnectInfo();  //抽象方法（无花括号）

    public void steType() {   //普通方法
        this.type = type;
    }

    public String getType() {   //普通方法
        return this.type;
    }
}

class DatabaseMessage extends Message {   //类的继承
    public String getConnectInfo() {    //方法覆写（必须）
        return "orcale数据库的连接信息";
    }
}

public class Demo {
    public static void main(String[] args) {
        Message msg = new DatabaseMessage();  //向上转型
        System.out.println(msg.getConnectInfo());
    }
}

包装类

• 包装类的主要功能：针对于基本数据类型的对象转换而实现的
• 包装类的两种类型：

1.对象型包装类(Object直接子类)：Boolean，Character
2.数值型包装类(Number直接子类)：Byte,Short,Integer,Long,Float,Double

• Number类是抽象类，该类定义有如下的方法：

方法名称	描述
public byte byteValue()	从包装类中获取byte数据
public short shortValue()	从包装类中获取short数据
public abstract long longValue()	从包装类中获取long数据
public abstract int intValue()	从包装类中获取int数据
public abstract float floatValue()	从包装类中获取float数据
public abstract double doubleValue()	从包装类中获取double数据

接口（interface）

• 接口的定义

interface IMessage {   //定义了一个接口
    public static final String INFO="www.mldn.cn";  //全局变量
    public abstract String getInfo();  //抽象方法
}

• 接口使用原则：

1.接口需要被子类实现（implements），一个子类可以实现多个父接口
2.子类（如果不是抽象类）那么一定要覆写接口中的全部抽象方法
3.接口对象可以利用子类对象的向上转型进行实例化

• 定义接口子类

interface IMessage {   //定义了一个接口
    public static final String INFO = "www.mldn.cn";  //全局变量

    public abstract String getInfo();  //抽象方法
}

class MessageImpl implements IMessage {  //实现接口
    public String getInfo() {
        return "得到一个秘密消息";
    }
}

public class Demo {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl() ;
        System.out.println(msg.getInfo());
        System.out.println(IMessage.INFO  ); //直接输出全局常量
    }
}

• List item

• 抽象类与接口的区别

区别	抽象类	接口
定义关键字	abstract class 抽象类名称{}	interface 接口名称{}
组成	构造，普通方法，静态方法，全局变量，普通成员，static方法	抽象方法，全局变量，普通方法，static方法
权限	可使用各种权限定义	只能使用public
子类使用	子类通过extends关键字可以继承一个抽象类	子类使用implements关键字可以实现多个接口
两者关系	抽象类可以实现若干个接口	接口不允许继承抽象类，但允许继承多个父接口

• 抽象类和接口的使用条件

1.抽象类或接口必须定义子类
2.子类一定要覆写抽象类或接口中的全部抽象方法
3.通过子类的向上转型实现抽象类或接口的实例化

泛型

• 泛型使用注意：

1.泛型之中只允许设置引用类型，如果现在要操作基本类型必须使用包装类
2.从jdk1.7开始，泛型对象实例化可以简化为“”

class Point <T>{   //T是Type的缩写，可以定义多个泛型
    private T x;
    private T y;
    public void setX(T x){
        this.x=x;
    }

    public void setY(T y) {
        this.y = y;
    }

    public T getX() {
        return this.x;
    }

    public T getY() {
        return this.y;
    }
}
public class Demo {
    public static void main(String[] args) {
        Point<Integer> point=new Point<Integer>();
        point.setX(10);
        point.setY(20);
        int x= point.getX() ;  //自动装箱
        int y= point.getY() ;  //自动装箱
        System.out.println("x坐标:"+x+"y坐标:"+y);
    }
}

• 泛型通配符：?

1.通配符的上界：<? extends  T>，表示该通配符所代表的类型是T类型的子类。
2.通配符的下界：<? super  T>，表示该通配符所代表的类型是T类型的父类。

• 泛型接口

interface IMessage<T>{
    public String echo(T t);
}

• 泛型方法

Lamda表达式

链表

//创建一个链表的类
class ListNode{
	int val;	//数值 data
	ListNode next;	// 结点 node
	
	ListNode(int x){	//可以定义一个有参构造方法，也可以定义一个无参构造方法
		val = x;
	}
	// 添加新的结点
	public void add(int newval) {
		ListNode newNode = new ListNode(newval);
		if(this.next == null)
			this.next = newNode;
		else
			this.next.add(newval);
	}
	// 打印链表
	public void print() {
		System.out.print(this.val);
		if(this.next != null)
			{
				System.out.print("-->");
				this.next.print();
			}
	}
}

• 数据保存：public void add(E e)
• 获取数据长度：public int size()
• 空集合判断：public boolean isEmpty()
• 返回集合数据：public Object[] toArray()
• 获取指定索引数据：public E get(int index)
• 修改指定索引的数据：public void set(int index,E data)
• 判断指定数据是否存在：public boolean contains(E data)
• 数据删除：public void remove(E data)
• 清空列表:public void clean()