目录
浅拷贝
简单理解：定义了A，A里面有age和num，拷贝成为B，B里面有age和num
package demo1浅克隆和深克隆;
//interfaces 是定义了一个接口
//implements是使用这个接口的关键字
//implements Cloneable：使用这个接口并且克隆一份
class Person implements Cloneable{
//声明
public int age;
//调用使用
public Person(int age){
this.age=age;
}
//这个方法是用于复制当前类的一个实例
//通过调用该方法，可以得到一个与原始对象相同属性的新对象。
@Override
protected Object clone() throws CloneNotSupportedException {
//uper是关键字，它被用于引用当前类的父类或直接父类中的方法、属性等。
return super.clone();
}
//这个代码段定义了一个类toString()
//它会将实例中的属性打印成一个字符串
//例如，在这里，它会根据Person类中定义的age属性
//生成如下输出：Person{age=30}
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
}
public class Test克隆案例浅拷贝 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1=new Person(10);
Person person2= (Person) person1.clone();
System.out.println(person1);
System.out.println(person2);
}
}深拷贝
简单理解：定义了A，A里面有age和num，修改A中age变成k，拷贝成为B，B里面有k和num
package demo1浅克隆和深克隆;
//加的类，副加函数克隆
class Money implements Cloneable{
public double money=19.9;
//证明我能被克隆
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
//主函数克隆
class Jkl implements Cloneable{
public int age;
//加的成员
public Money m;
//构造方法
public Jkl(int age){
this.age=age;
//在构造方法里面进行实例化一次
this.m=new Money();
}
//在主函数里面调用附加函数克隆
@Override
protected Object clone() throws CloneNotSupportedException {
//return super.clone();
//用Jkl来接收克隆出来的对象，再进行修改
Jkl tmp=(Jkl) super.clone();
//main中是jkl1调用克隆出19.9
tmp.m=(Money) this.m.clone();
//tmp是常量最后会自动释放
//所以用jkl2来指向tmp指向的值
return tmp;
}
@Override
public String toString() {
return "Jkl{" +
"age=" + age +
'}';
}
}
public class Test深拷贝 {
public static void main(String[] args) throws CloneNotSupportedException {
Jkl jkl1=new Jkl(10);
Jkl jkl2= (Jkl) jkl1.clone();
System.out.println(jkl1);
System.out.println(jkl2);
System.out.println("==================");
//修改成下面这样的形式
System.out.println(jkl1.m.money);
System.out.println(jkl2.m.money);
System.out.println("==================");
jkl2.m.money=99.99;
System.out.println(jkl1.m.money);
System.out.println(jkl2.m.money);
}
}内部类
将一个类定义在另一个类的内部
匿名内部类
package demo内部类;
//一个类一个字节码文件
//定义一个接口，接口里面定义一个方法 给匿名内部类
interface A{
void testA();
}
public class Test匿名内部类 {
public static void main(String[] args) {
//匿名内部类
//下面代码可以认为：有一个类，实现了A接口并且重写了A接口中的方法
//匿名写法调用方式1
/*new A(){
@Override
public void testA() {
System.out.println("hehe");
}
}.testA();*/
//匿名写法调用方式2
A a = new A(){
//重写我的testA()方法
@Override
public void testA() {
System.out.println("hehe");
}
};
//能够访问的是，没有被修改过的数据（变量的捕获）
//即默认访问被final修饰的量（常量）
a.testA();
}
}实例内部类
package demo内部类;
/*
* 1.如何获取实例内部类
* 2.在实例内部类中，是否可以定义静态的成员变量？
* public static final int data6=6;中间加个final
* 因为final是修饰常量，实力内部类要依赖普通类
* 3.当实例内部类和普通类都定义了的public int data1;
* 在实例内部类中打印的data1是先打印data1所在的类
* （this.data也是）一样的，所以输出11111.
* 如果我硬要用实例内部类中的data1打印普通类（在实例内部类外面）的data1值
* 那么就：普通类名+this.data1(OuterClass.this.data1)
*
* 实例内部类的缺点：每次使用都要创建一个普通类，通过它来引用实例内部类
* 静态内部类则不用这样
*
* */
//OuterClass这个普通类
class OuterClass{
//普通的成员变量
public int data1=1;
private int data2=2;
public static int data3=3;
//普通的成员内部类
//实例内部类
class InnerClass{
public int data1=11111;
public int data4=4;
private int data5=5;
public static final int data6 = 6;
//定义普通的成员方法
public void test(){
System.out.println(data1);
System.out.println(OuterClass.this.data1);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
System.out.println("内部类的test方法");
}
}
//普通类自己的方法
public void test(){
System.out.println("外部类的test方法");
}
}
public class Test实例内部类 {
public static void main(String[] args) {
//如何使用内部类
//先声明正常类的调用
//外部类名 外部对象名
OuterClass outerClass=new OuterClass();
System.out.println(outerClass.data1);
System.out.println("==================");
//再在正常内部类上调用实例内部类
//1.总结：获取一个实例内部类对象，依赖于外部类对象(外部类名.内部类名 内部对象名 =外部对象名.new 内部类名)
// 用对象
//调用方式1
OuterClass.InnerClass innerClass=outerClass.new InnerClass();
innerClass.test();
//调用方式2
//因为outerClass=new OuterClass(); 所以替换掉outerClass
//OuterClass.InnerClass innerClass2=new OuterClass().new InnerClass();
//innerClass2.test();
}
}静态内部类
package demo内部类;
/*
*1.如何获取实例内部类
* （外部类名.内部类名 内部对象名=new 外部类名.内部类名）
* 2.在实例内部类中，是否可以定义非静态（外部）的成员变量？
* 直接在静态里面声明就可以去使用了
* OuterClass outerClass=new OuterClass();
System.out.println(outerClass.data1);
*/
//在同一个包里面重名了，所以加上2来区分
class OuterClass2 {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类---不依赖外部对象
static class InnerClass {
//当此语句被屏蔽了，data1也不会打印OuterClass2中data1=1的值
//public int data1=111;
public int data4=4;
private int data5=5;
public static int data6 = 6;
public void test(){
OuterClass outerClass=new OuterClass();
System.out.println(outerClass.data1);
System.out.println("==========");
//System.out.println(data1);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
System.out.println("内部类的test方法");
}
}
}
public class Test静态内部类 {
public static void main(String[] args) {
//静态的东西是需要 （外部类名.内部类名 内部对象名=new 外部类名.内部类名）去访问的
// 用类名
OuterClass2.InnerClass innerClass=new OuterClass2.InnerClass();
innerClass.test();
}
}外部类
将一个类定义在一个方法的内部
//抽象类
public abstract class Shape {
private String color;
public Shape(String color) {
this.color = color;
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public abstract void draw();
}
public class Circle extends Shape {
private int radius;
public Circle(String color, int radius) {
super(color);
this.radius = radius;
}
@Override
public void draw() {
System.out.println("Drawing a circle of radius " + radius + " with color " + getColor());
}
}
public class Rectangle extends Shape {
private int width;
private int height;
public Rectangle(String color, int width, int height) {
super(color);
this.width = width;
this.height = height;
}
@Override
public void draw() {
System.out.println("Drawing a rectangle of width " + width + " and height " + height + " with color " + getColor());
}
}
//接口
public interface Flyable {
void fly();
}
public class Bird implements Flyable {
public void fly() {
System.out.println("Bird is flying...");
}
}
public class Airplane implements Flyable {
public void fly() {
System.out.println("Airplane is flying...");
}
}
//外部类
public class Main {
public static void main(String[] args) {
Circle circle = new Circle("Red", 10);
Rectangle rectangle = new Rectangle("Blue", 20, 30);
circle.draw();
rectangle.draw();
Bird bird = new Bird();
Airplane airplane = new Airplane();
bird.fly();
airplane.fly();
}
}