当前位置: 代码迷 >> 综合 >> Java学习日志-第13天
  详细解决方案

Java学习日志-第13天

热度:74   发布时间:2024-01-17 02:01:07.0
package day_05._01_ClassRelation;public class ClassRelation_01 {// 关联关系,成员变量保存了另一个类 对象引用// 关系是长期的A a = new A();public static void main(String[] args) {// 依赖关系,局部变量,保存另一个类 对象引用// 方法执行完,关系就不存在了A a = new A();}
}
// 类之间单继承
class A{}
class B extends A{}
interface C{}
interface D{}
// 接口之间多继承
interface E extends C,D{}
// 类和接口之间多实现
class F implements C,D{}
package day_05._01_ClassRelation;public class ClassRelation_02 {public static void main(String[] args) {Person person = new Person();Test t1 = new Test(person);System.out.println(t1.person);Test t2 = new Test(person);System.out.println(t2.person);}
}
class Test{// 关联关系,但是这个对象是自己创建的// person对象的生命周期会和Test对象的生命周期绑定// 当我们创建了多个Test对象的时候,一般也会创建多个Person对象// 由于该person对象是手动创建的,那么也就意味着,其他地方没有保存person的引用// 当test对象销毁时,该person对象也被视为垃圾数据,等待被回收// Person person = new Person();// 如果不手动创建,需要调用处传递,那就不一样了,此时尽管test对象销毁,那么调用处依然保存了person对象的引用// 那么 person就不会是垃圾数据,不用被回收,还可以继续复用Person person;public Test(Person person) {this.person = person;}}
class Person{}
package day_05._01_ClassRelation;public class Student {private int id;private String name;private int age;private Teacher teacher;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Teacher getTeacher() {return teacher;}public void setTeacher(Teacher teacher) {this.teacher = teacher;}}
package day_05._01_ClassRelation;public class Teacher {private int id;private String name;private int age;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}
package day_05._02_InnerClass;/*** 成员内部类,可以看做成员变量* * 内部类优点 : 可以访问外部类的私有化属性* * @author SEC90* @Date 2022年1月13日 上午10:30:44*/
public class OuterClass_01 {private static String s1 = "私有化静态变量";private String s2 = "私有化成员变量";// 成员内部类// 可以使用访问权限控制修饰符// 在成员内部类中不能有静态声明// 在成员内部类中,可以直接访问外部类所有属性// 内部类类名 编译之后 : 外部类类名$内部类类名class InnerClass {// static int i = 2;public void m1(){System.out.println(s1);System.out.println(s2);}}public static void main(String[] args) {// 1 创建外部类对象OuterClass_01 o = new OuterClass_01();// 2 创建内部类对象InnerClass inner = o.new InnerClass();// 3 访问属性inner.m1();}
}
package day_05._02_InnerClass;
/*** 静态内部类 可以看做静态变量* * 在静态内部类中,可以声明成员属性也可以声明静态属性* * 在静态内部类中,无法直接访问外部类的成员属性,需要创建外部类对象访问才行* * @author SEC90* @Date 2022年1月13日 上午10:40:01*/
public class OuterClass_02 {private static String s1 = "私有化静态变量";private String s2 = "私有化成员变量";static class InnerClass{public static void m1(){System.out.println(s1);// System.out.println(s2);}public void m2(){System.out.println(s1);// System.out.println(s2);}}public static void main(String[] args) {// 调用m1OuterClass_02.InnerClass.m1();// 当前类中 类名可以省略InnerClass.m1();// 创建静态内部类对象InnerClass inner = new OuterClass_02.InnerClass();// 类名可以省略inner = new InnerClass();// 调用m2inner.m2();}
}
package day_05._02_InnerClass;/*** 局部内部类可以看做局部变量 ,* * 如果通过局部内部类访问外部方法中的局部变量的时候,该变量需要加final修饰,但是在1.8开始,final可以省略* * 局部内部类,不能使用权限修饰符 也不能使用static* * 局部内部类的类名为外部类类名$1内部类类名,假如内部类类名一样了,那么就是外部类类名$2内部类,以此类推* * @author SEC90* @Date 2022年1月13日 下午2:06:40*/
public class OuterClass_03 {private static String s1 = "私有化静态变量";private String s2 = "私有化成员变量";public static void main(String[] args) {}// 静态方法中的局部内部类,无法直接使用外部类中的成员属性public static void m1() {final int age = 19;class InnerClass {// public static void m1(){}public void m3() {System.out.println(age);System.out.println(s1);// System.out.println(s2);}}}// 成员方法中的内部类,可以直接访问外部类中的所有属性public void m2() {final int age = 19;// age = 2;class InnerClass {// public static void m1(){}public void m3() {System.out.println(age);System.out.println(s1);System.out.println(s2);}}// 局部内部类调用InnerClass i = new InnerClass();i.m3();}
}
package day_05._02_InnerClass;import java.util.LinkedList;/*** 匿名内部类 : 在方法调用的时候,需要传入一个接口的实现类对象的时候,可以不写实现类,直接写一个匿名内部类* * 类名为 外部类类名$1, 外部类类名$2 以此类推* * @author SEC90* @Date 2022年1月13日 下午2:16:13*/
public class OuterClass_04 {public static void test(IUserService userService) {userService.login();}public static void main(String[] args) {// UserServiceImpl userServiceImpl = new UserServiceImpl();// test(userServiceImpl);// 优点 少定义一个类,并且还能访问外部类中的私有化属性,// 缺点 : 无法复用test(new IUserService() {@Overridepublic void login() {System.out.println("登陆成功");}});}
}interface IUserService {public void login();
}// class UserServiceImpl implements IUserService {
// @Override
// public void login() {
// System.out.println("登陆成功");
// }
// }
package day_05._03_Singleton;public class Client {public static void main(String[] args) {System.out.println(Singleton_01.getInstance());System.out.println(Singleton_01.getInstance());System.out.println(Singleton_01.getInstance());System.out.println(Singleton_01.getInstance());System.out.println(Singleton_01.getInstance());System.out.println(Singleton_01.getInstance());System.out.println("====");System.out.println(Singleton_02.getInstance());System.out.println(Singleton_02.getInstance());System.out.println(Singleton_02.getInstance());System.out.println(Singleton_02.getInstance());System.out.println(Singleton_02.getInstance());}}
package day_05._03_Singleton;/*** 设计模式 : 就是在编码实践中,人们发现有很多的编码经常被用到,* * 于是就总结出来,形成固定的结构,该结构一般代表了最佳的实现方式* * 让当前类只能被创建一个实例化对象* * 1 要控制创建对象的数量,也就意味着 不能让客户,直接操作构造方法* 			所以 需要构造方法私有化* 2 对外提供一个用于获取对象的方法* 			没有入参 , 出参是当前类类型 的静态方法* * 3 创建一个静态变量,用来保存实例化之后的对象* * 结合对象的创建时机不同,又分为两种情况* 		1 加载阶段就创建对象,称为饿汉模式* 		2 用到的时候,再创建对象,称为懒汉模式* * @author SEC90* @Date 2022年1月13日 下午2:36:51*/
public class Singleton_01 {private static Singleton_01 s = new Singleton_01();public static Singleton_01 getInstance() {return s;}
}
package day_05._03_Singleton;/*** 		2 用到的时候,再创建对象,称为懒汉模式* * @author SEC90* @Date 2022年1月13日 下午2:36:50*/
public class Singleton_02 {private static Singleton_02 s = null;public static Singleton_02 getInstance() {if (s == null) {s = new Singleton_02();}return s;}
}