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类是抽象类，该类定义有如下的方法：

接口（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

• 抽象类与接口的区别

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

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()

最后

以上就是冷静高山为你收集整理的2021-02-23的全部内容，希望文章能够帮你解决2021-02-23所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。