（1-4）Java Object类、Final、注解、设计模式、抽象类、接口、内部类

目录

1. Object类

 1.1 equals

1.2 toString（）

2.final关键字

3.注解

4. 设计模式

 4.1 单例模式

4.1.1 饿汉式

4.1.3 饿汉式 VS 懒汉式

5. 抽象类&抽象方法

6. 接口

7.内部类 

7.1 成员内部类

7.2 静态内部类

7.3 方法内部类

7.4 匿名内部类

---

1. Object类

 1.1 equals

重写Object 的equals方法，两种实现方式

 

1.2 toString（）

 

2.final关键字

 

 

3.注解

4. 设计模式

设计模式是基于场景的解决方案

 4.1 单例模式

 

4.1.1 饿汉式

代码实现：

package org.example;/***   01   饿汉式 ： 创建对象实例的时候直接初始化**   典型的空间换时间，类加载的的时候  ==>静态实例对象完成初始化操作*/
public class SingletonOne {// 1. 创建类中的私有构造private SingletonOne(){}// 2. 创建改类型的私有静态实例   (创建并实例化)private static SingletonOne instance = new SingletonOne();// 3. 创建公有静态方法返回静态实例对象public static SingletonOne getInstance(){return instance;}
}

测试结果：

import org.example.SingletonOne;public class test {public static void main(String[] args) {
//        SingletonOne one = new SingletonOne();SingletonOne one = SingletonOne.getInstance();SingletonOne two = SingletonOne.getInstance();System.out.println(one);  //[e-mail](two);  //[e-mail](one == two);      //trueSystem.out.println(one.equals(two));   //true}
}

4.1.2 懒汉式

package org.example;/*** 02 懒汉式** 类内实例对象创建时并不初始化，直到第一次调用get方法时，才完成初始化操作* 用时间换取空间的一种编码模式*/
public class SingletonTwo {// 01 创建私有构造方法private SingletonTwo(){}// 02 创建开放的静态方法提供实例对象public static SingletonTwo instance = null;// 03. 创建开放的实例方法提供实例对象public static SingletonTwo getInstance(){if(instance == null){instance = new SingletonTwo();}return instance;}
}

测试

import org.example.SingletonOne;
import org.example.SingletonTwo;public class test {public static void main(String[] args) {System.out.println("=====================");SingletonTwo one1 = SingletonTwo.getInstance();SingletonTwo two1 = SingletonTwo.getInstance();System.out.println(one1);   //[e-mail](two1);   //[e-mail](one1 == two1);  //true}
}

4.1.3 饿汉式 VS 懒汉式

5. 抽象类&抽象方法

/*** 抽象类： 这个类不允许被实例化了，可以通过向上转型，转向子类实例*/
public abstract class Animal {
//    public void eat(){
//        System.out.println("动物都需要吃东西");
//    }// 抽象方法没有方法体// 子类继承父类也必须重写父类的抽象方法，否则也需要将子类定义为抽象类// static、final、private   不能与abstract并存public abstract void eat();
}

6. 接口

定义接口

public interface INet {/*** 接口中抽象方法可以不写abstract关键字** 默认访问修饰符 public** ==> 当类实现接口时，需要实现接口中的所有抽象方法，否则需要将该类设置为抽象类*/void network();// 接口中可以包含常量， 默认public、 static、 finalint TEMP = 20;// default:默认方法 可以带方法体         jdk1.8后新增的// 可以在实现类中重写,并可以通过接口的引用调用default void connection(){System.out.println("我是接口中的默认链接");}//静态方法也可以待方法体                 jdk1.8后新增的// 不可以在实现类中重写, 可以通过接口名调用static void stop(){System.out.println("我是接口中的静态方法");}
}

实现接口

package com.vb.tel;public class SmartPhoto implements INet{
//    public static final int TEMP = 30;public int TEMP = 30;public void call(){System.out.println("Calling SmartPhoto");}public void network(){System.out.println("Networking SmartPhoto");}@Overridepublic void connection() {//调用接口中的默认方法INet.super.connection();System.out.println("Connection SmartPhoto");}
}

测试类

public class PhoneTest {public static void main(String[] args) {FourthPhone phone4 = new FourthPhone();phone4.game();            //可以玩游戏phone4.getBrand();phone4.call();            //手机可以拨打电话System.out.println("================");IPhoto ip = new FourthPhone();ip.photo();                     //拍照ip = new Camera();ip.photo();                   //相机可以拍照System.out.println("================");System.out.println(INet.TEMP);   //20INet net = new SmartPhoto();System.out.println(net.TEMP);    //20net.connection();//我是接口中的默认链接//Connection SmartPhoto// 接口中的静态方法需要通过接口名来调用INet.stop();               //我是接口中的静态方法}
}

7.内部类 

7.1 成员内部类

        内部类中最常见的，也称为普通内部类

内部类

package com.vb.people;// 外部类
public class Person {public int age;public void eat(){System.out.println("People eat");}// 获取内部类的方法public Heart getHeart(){new Heart().temp = 25;return new Heart();}//成员内部类/*** 1. 内部类在外部使用时,无法直接实例化* 选哟借助外部类信息才能完成实例化* 2. 内部类可以直接方法外部类的成员;如果出现同名属性,优先访问内部类中定义的* 3. 可以通过使用外部类.this.成员的方式,访问外部类中同名的信息* 4. 外部类访问内部类的信息,需要通过内部类实例,无法直接方问* 5. 内部类编译后.class文件明明: 外部类$内部类.class*///注: 不加public的话只能在同胞中调用public class Heart {int age = 13;int temp = 22;public String beat(){eat();return Person.this.age+"心脏在跳动";}}
}

测试类

package com.vb.people;public class PeopleTest {public static void main(String[] args) {Person vb = new Person();vb.age = 25;// 同包下访问内部类
//        Heart heart = new Heart();    //不可行//获取内部类对象实例:  ==>//方式1:  ==> new 外部类.new 内部类Person.Heart myHeart = new Person().new Heart();System.out.println(myHeart.beat());   //0心脏在跳动// 方式2: 通过外部类对象获取内部类实例   ==> 外部类对象.new 内部类Person.Heart heart1 = vb.new Heart();System.out.println(heart1.beat());    //25心脏在跳动// 方式3: 通过外部类对象 获取方法   ==> 外部类对象.获取方法heart1 = vb.getHeart();System.out.println(heart1.beat());    //25心脏在跳动}
}

7.2 静态内部类

        静态内部类对象可以不依赖于外部类对象，直接创建

// 外部类
public class Person {public int age;//    public static void eat(){public void eat(){System.out.println("People eat");}// 获取内部类的方法public Heart getHeart(){new Heart().temp = 25;return new Heart();}//02 静态内部类/*** 1. 静态内部类中,只能访问外部类的静态成员,如果需要调用非静态成员,可以通过对象实例* 2. 创建静态内部类对象实例时,不依赖于外部类对象* 3. 可以通过(外部类.内部类.静态成员)的方式,访问内部类中的静态成员* 4. 当内部类访问外部类中的静态属性,则可以通过(外部类.属性)的方式;*    若需要访问外部类中的静态属性,则可以通过外部类.属性的方式;*    若需要访问外部类中的非静态属性,则可以通过 new 外部类().属性  的方式*/public static class Heart {public static int age = 13;int temp = 22;public static void say(){System.out.println("say hello");}public String beat(){new Person().eat();return new Person().age+"心脏在跳动";}}
}

测试类

public class PeopleTest {public static void main(String[] args) {Person vb = new Person();//获取静态内部类对象实例Person.Heart myHeart = new Person.Heart();System.out.println(myHeart.beat());//People eat//0心脏在跳动Person.Heart.say();             //say helloSystem.out.println(Person.Heart.age);    //13}
}

7.3 方法内部类

        方法内部类是定义在外部方法中的内部类，也称局部内部类

注:方法内不能定义静态成员

// 外部类
public class Person {public int age;public void eat(){System.out.println("People eat");}//03 方法内部类public Object getHeart(){/***  1. 定义在方法内部,作用范围也在方法内*  2. 和方法内部成员使用规则一样,class前面不可以添加public等修饰符 & static*  3. 类中不能包含静态成员*  4. 类中可以包含final\ abstract 修饰的成员*/
//       abstract class Heart {class Heart {public final int age = 13;int temp = 22;public final void say(){System.out.println("say hello");}//            public abstract void eat();public String beat(){new Person().eat();return new Person().age+"心脏在跳动";}}return new Heart().beat();}

测试

public class PeopleTest {public static void main(String[] args) {Person vb = new Person();vb.age = 25;//03 方法内部类System.out.println(vb.getHeart());//People eat//0心脏在跳动}
}

7.4 匿名内部类

将类的定义与类的创建，放在一起完成

（1）普通方案 & 多态重载方式实现

Person.java

package com.vb.anonymous;public abstract class Person {private String name;public Person(){}public String getName() {return name;}public void setName(String name) {this.name = name;}public abstract void read();
}

Man.java

package com.vb.anonymous;public class Man extends Person{@Overridepublic void read() {System.out.println("Man read");}
}

Woman.java

package com.vb.anonymous;public class Woman extends Person {@Overridepublic void read() {System.out.println("Woman read");}
}

Test

public class PersonTest {// 需求: 根据传入不同的人的类型, 调用对应的方法// 方案1:
//    public void getRead(Man man){
//        man.read();
//    }
//    public void getRead(Woman woman){
//        woman.read();
//    }// 方案 2  多态=>方法的重载public void getRead(Person person){person.read();}public static void main(String[] args) {PersonTest test = new PersonTest();Man man = new Man();Woman woman = new Woman();test.getRead(man);       //Man readtest.getRead(woman);     //Woman read}}

(2)匿名内部类实现

public class PersonTest {// 需求: 根据传入不同的人的类型, 调用对应的方法public void getRead(Person person){person.read();}public static void main(String[] args) {PersonTest test = new PersonTest();// 方案3: 匿名内部类/*** 1. 匿名内部类没有类型名称\ 实例对象名称* 2. 编译后的文件命名: 外部类$数字.class* 3. 无法使用访问修饰符& static &abstract* 4. 无法编写构造方法* 5. 无法出现静态成员* 6. 可以实现接口,也可以继承父类,但不可兼得* 实例对象的同时,完成对于对象内容的编写* 适用于: 只用到类的一个实例的场景*        在类的定义后马航用到*        给类的命名并不会导致代码更容易被理解*/test.getRead(new Person() {@Overridepublic void read() {System.out.println("man read");        //man read}});test.getRead(new Person(){@Overridepublic void read(){System.out.println("woman read");      //woman read}});}
}