Java OOP

最新推荐文章于 2024-07-19 17:37:28 发布

Geollan

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量128

点赞数

分类专栏： Java Learning 文章标签： java

本文链接：https://blog.csdn.net/weixin_46755489/article/details/107520652

版权

Java Learning 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

面向对象编程

面向过程 & 面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二部做什么…
- 面对过程适合处理一些较为简单的问题
面对对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程（Object-Oriented Programming, OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后又有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模版。

public class CreateStudent
{
    public static void main(String[] args)
    {
        //实例化这个类 new
        //对象类型 对象名 = 对象值;
        
        Student student = new Student();
        student.say();
    }
    
    //和类一起加载的
    public static void a()
    {
        b(); //会报错
    }
    
    //类实例化之后才存在
    public void b()
    {
        
    }
}

class Student
{
    //非静态方法
    public void say()
    {
        System.out.println("学生说话了");
    }
}

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下两个特点：
1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void
构造器必须要掌握

//一个项目应该只存在一个main方法
public class Application
{
    public static void main(String[] args)
    {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例!
        
        Studnet George = new Student();
        Student Paul = new Studnet();
        Student Kobe = new Student("Geollan");
        
        George.name = "George";
        George.age = "29";
        System.out.println(George.name + " " + George.age);
        
        Paul.name = "Paul”;
        Paul.age = 35;
        System.out.println(Paul.name + " " + Paul.age);
    }
}


class Student
{
    //属性：字段
    String name;
    int age;
    
    //1.使用new 关键字必须要有构造器
    //2.用来初始化值
    public Student()
    {
        
    }
    
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Student(String name)
    {
        this.name = name;
    }
    
    //方法
    public void study()
    {
        System.out.println("学生在学习");
    }
    
    /*
    构造器：
    	1.和类名相同
    	2.没有返回值
    作用：
    	1.new 本质在调用构造方法
    	2.初始化对象的值
    注意点：
    	1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
    */
}

标准类

/*
一个标准的类通常要拥有下面四个组成部分：

1.所有的成员变量都要使用private关键字修饰
2.为每一个成员变量编写一对Getter/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

这样标准的类也叫做Java Bean
*/

public class Student
{
    private String name; //姓名
    private int age; //年龄
    
    public Student()
    {
        
    }
    
    public Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    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;
    }
    
}

封装

该露的露，该藏的藏
- 我们程序设计要追求***高内聚，低耦合***。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这就称为信息隐藏。
记住这句话就够了：属性私有， get/set

/*
	1.提高程序的安全性，保护数据
	2.隐藏代码的实现细节
	3.统一接口
	4.系统可维护性增加了
*/

public class Application
{
    public static void main(String[] args)
    {
        Student s1 = new Student();
        
        s1.setName("Geollan");
        
        System.out.println(s1.getName());
        
        s1.setAge(-1);//不合法的
        System.out.println(s1.setAge());
    }
}

/*
用private关键字将需要保护的成员变量进行修饰，可以阻止不合理的数值被设置进来。
一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
但是！超出了本类范围之外就不能再直接访问了。

间接访问private成员变量，就是定义一对Getter/Setter方法

必须叫setXXX或者getXXX命名规则
对于Getter来说，不能有参数，返回值类型和成员变量对应。
对于Setter来说，不能有返回值，参数类型和成员变量对应。
对于基本类型当中的boolean值，Getter方法一定要写成isXXX的形式，而Setter方法规则不变。
*/

class Student
{
    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    
    //这个成员方法，专门用于获取name的数据
    public String getName()
    {
        return this.name;
    }
    
    //这个成员方法，专门用于向name设置数据
    public void setName(String name)
    {
        this.name = name;
    }
    
    public int getId()
    {
        return this.id;
    }
    
    public void setId(int id)
    {
        this.id = id;
    }
    
    public char getSex()
    {
        return this.sex;
    }
    
    public void setSex(char sex)
    {
        this.sex = sex;
    }
    
    public int getAge()
    {
        return this.age;
    }
    
    public void setAge(int age)
    {
        if(age > 120 || age < 0) //数据不合理
            this.age = 1;
        else
            this.age = age;
    }
    
    //alt + insert 在idea中自动生成get/set 方法
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
***extends***的意思是“扩展”。子类就是父类的扩展。
Java中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is-a”的关系
object类
super
方法重写

//在Java中，所有的类都默认直接或者简介继承object类
//Person ：父类
class Person
{
    //public
    //protect
    //default
    //private
    
    int money = 10000000; //default
    private int age = 39; //private
}


//Teacher is a Person：派生类，子类
//子类继承了父类，就会拥有父类的全部方法；
class Teacher extends Person
{
    
}


//Student is a Person：派生类，子类
class Student extends Person
{
    
}

/*
局部变量：          直接写成员变量
本类的成员变量：     this.成员变量名
父类的成员变量：     super.成员变量名


在父子类的继承关系中，创建子类对象，访问成员方法的规则：
	创建的对象是谁，就优先用谁，如果没有则向上找。
	
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
*/

public class Application
{
    public static void main(String[] args)
    {
        Student student = new Student();
        student.test1("Geollan");
        student.test2();
    }
}

class Person
{
    protected String name = "Paul";
    
    public Person()
    {
        System.out.println("Person无参执行了");
    }
    
    public print()
    {
        System.out.println("Person");
    }
}
/*
继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造
总结：
子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个。
*/

class Student extends Person
{
    private String name = "George";
    
    public Student()
    {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }
    
    public void test1(String name)
    {
        System.out.println(name);//Geollan 局部变量
        System.out.println(this.name);//George 本类的成员变量
        System.out.println(super.name);//Paul 父类的成员变量
    }
    
    public void print()
    {
        System.out.println("Student");
    }
    
    public void test2()
    {
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}

/*
super注意点：
	1.super调用父类的构造方法，必须在构造方法的第一个
	2.super必须只能出现在子类的方法或者构造方法中！
	3.super和this不能同时调用构造方法！

VS this：
	代表的对象不同：
		this：本身调用者这个对象
		super：代表父类对象的应用
	前提
		this：没有继承也可以使用
		super：只能在继承条件下才可以使用
	构造方法
		this()：本类的构造
		super()：父类的构造
*/

/*
重写（ Override)
概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写（Override)：方法的名称一样，参数列表【也一样】。覆盖、重写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法签名，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。
*/

class B
{
    public static void test()
    {
        System.out.println("B=>test()");
    }
    
    public void test2()
    {
        System.out.println("B=>test2()")
    }
}

class A extends B
{
     public static void test()
    {
        System.out.println("A=>test()");
    }
    
    //Override 重写
    @Override //注解：有功能的注释！
    public void test2()
    {
        //super.test2();
        System.out.println("A=>test2()");
    }
}

public class Application
{
    //静态方法和非静态方法的区别很大！
    //静态方法：方法的调用只和左边，定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args)
    {
        A a = new A();
        a.test();//A=>test()
        a.test2();//A=>test2()
        
        
        //父类的引用指向了子类
        B b = new A();
        b.test();//B=>test()
        b.test();//A=>test2()
    }
}

/*
重写：需要有继承关系，子类重写父类的方法！
	1.方法名必须相同
	2.参数列表必须相同
	3.修饰符：范围可以扩大但不能缩小 public>Protected>Default>private
	4.抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

重写，子类的方法和父咧必须一致：方法体不同！

为什么需要重写：
	父类的功能，子类不一定需要，或者不一定满足！
	
*/

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
instanceof

/*
代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
格式：
父类名称 对象名 = new 子类名称();
或者
接口名称 对象名 = new 实现类名称();

口诀：编译看左边，运行看右边。

对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。
*/

public class MultiExample
{
    public static void main(Strnig[] args)
    {
        //使用多态的写法
        //左侧父类的引用，指向了右侧子类的对象
        Person p = new Student();
        
        p.method(); //子类方法
        p.methodPerson(); //父类特有方法
    }
}

class Person
{
    public void method()
    {
        System.out.println("父类方法");
    }
    
    public void methodPerson()
    {
        System.out.println("父类特有方法");
    }
}

class Student extends Person
{
    @Override
    public void method()
    {
        System.out.println("子类方法");
    }
}

/*
访问成员变量的两种方式：

1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
*/

public class MultiFieldExample
{
    public static void main(Strnig[] args)
    {
        //使用多态的写法，父类引用指向子类对象
        Person p = new Student();
        
        System.out.println(p.num); //10
        
        //子类没有覆盖重写，就是父类中的方法：10
        p.showNum(); 
    }
}

class Person
{
    int num = 10;
    
    public void showNum()
    {
        System.out.println(num);
    }
}

class Student extends Person
{
    int num = 20;
}

对象的向上转型，其实就是多态写法：
- 格式：父类名称对象名 = new 子类名称();
```
	Animal animal = new Cat();
```
- 含义：右侧创建一个子类对象，把它当做父类来看待使用。
- 注意事项：向上转型一定是安全的。从小范围转向了大范围，从小范围的猫，向上转换成为更大范围的动物。
- 类似于：
```
double num = 100; //正确， int --> double, 自动类型转换。
```

对象的向下转型，其实是一个【还原】动作。

格式：子类对象对象名 =(子类名称)对象名称;
含义：将父类对象，【还原】成为本来的子类对象。

Animal animal = new Cat(); //本来是猫，向上转型成为动物
Cat cat = (Cat)animal; //本来是猫，已经被当做成动物了，还原回来成为本来的猫

注意事项：
- 必须保证对象本来创建的时候，就是猫，才能向下转型为猫。
- 如果对象创建的时候本来不是猫，现在非要向下转型为猫，就会报错。
类似于：

int num1  = (int)10.0; //可以
int num2 = (int)10.5; //不可以，精度损失

/*
向上转型一定是安全的，没有问题的，正确的，但是也有一个弊端。
对象一旦向上转型为父类，那么就无法调用子类原本持有的内容。

解决方案：用对象的向下转型【还原】。
*/

abstract class Animal
{
    abstract void eat();
}

class Cat extends Animal
{
    @Override
    pubilc void eat()
    {
        System.out.println("猫吃鱼");
    }
    
    public void catchMouse()
    {
        System.out.println("猫抓老鼠");
    }
}

class dog extends Animal
{
    @Override
    pubilc void eat()
    {
        System.out.println("狗吃肉");
    }
    
    public void watchHouse()
    {
        System.out.println("狗看家");
    }
}

public class Example
{
    public static void main(Strnig[] args)
    {
        //对象的向上转型，就是，父类引用指向之前对象。
        Animal animal = new Cat(); //本来创建的时候是一只猫
        animal.eat(); //猫吃鱼
        
        //animal.catchMouse(); //错误写法！
        
        //向下转型，进行“还原”动作
        Cat cat = (Cat)animal;
        cat.catchMouse(); //猫抓老鼠
        
        //下面是错误的向下转型
        //本来new的时候是一只猫，现在非要当做狗
        //错误写法！编译不会报错，但是运行会出现异常：
        //java.lang.ClassCastException
        Dog dog = (Dog)animal;
    }
}

/*
如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
*/

class InstanceofExample
{
    public static void main(String[] args)
    {
        Animal animal = new Cat(); 
        animal.eat();
        
        //判断一下父类引用animal本来是不是Dog
        if(animal instanceof Dog)
        {
            Dog dog = (Dog)animal;
            dog.watchHouse();
        }
        
        //判断一下父类引用animal本来是不是Cat
        if(animal instanceof Cat)
        {
            Cat cat = (Cat)animal;
            cat.catchMouse();
        }
        
        giveMeAPet(new Dog());
    }
    
    public static void giveMeAPet(Animal animal)
    {
        if(animal instanceof Dog)
        {
            Dog dog = (Dog)animal;
            dog.watchHouse();
        }
        
        if(animal instanceof Cat)
        {
            Cat cat = (Cat)animal;
            cat.catchMouse();
        }
    }
}

super关键字详解

/*
super关键字的用法有三种：
1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。
*/

class Student extends Person
{
    int num = 20;
    
    public Student()
    {
        super();
    }
    
    public void methodStudent()
    {
        System.out.println(super.num); //父类中的num
    }
    
    public void method()
    {
        super.method(); //访问父类中的method
        System.out.println（"子类方法");
    }
}

class Person
{
    int num = 39;
    
    public Person()
    {
        
    }
    
    public void method()
    {
        System.out.println("父类方法");
    }
}

this关键字详解

/*
super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
在第三种用法当中要注意：
A. this(...)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。
*/

class Student extends Person
{
    String name = "Geollan";
    
    public Student()
    {
        //super(); 这一行不再赠送
        this(123); //本类的无参构造，调用本类的有参构造
        //this(1, 2); //错误写法
    }
    
    
    public Student(int n)
    {
        this(1, 2);
    }
    
    public Student(int n, int m)
    {
        
    }
    
    public void showName()
    {
        String name = "Geroge";
        System.out.println("名字是：" + name);
    }
}

class Person
{
    String name = "Kilon";
    
    public Person()
    {
        
    }
}

static关键字详解

public class Student
{
    private static int age; //静态的变量 多线程！
    private double score; //非静态的变量
    
    public void run()
    {
        
    }
    
    public static void go()
    {
        
    }
    
    public static void main(String[] args)
    {
        Student s1 = new Student();
        
        System.out.println(Student.age);
        System.out.println(Student.score);//会报错
        System.out.println(s1.age);
        System.out.println(s1.score);
        
        Student.go();
        Student.run(); //会报错
    }
}

public class Person
{
    //2
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    
    //1
    static 
    {
        //静态代码块：只执行一次～
        System.out.println("静态代码块");
    }
    
    //3
    public Person()
    {
        System.out.println("构造方法");
    }
    
    public static void main(String[] args)
    {
        Person person1 = new Person();
        /*
        打印顺序
        静态代码块
        匿名代码块
        构造方法
        */
        
        Person person2 = new Person();
        /*
        打印顺序
        匿名代码块
        构造方法
        */
    }
}

//静态导入包
import static java.lang.Math.random;

final 关键字

/*
final关键字代表最终、不可改变的。

常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量
*/

/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称
{
	//...
}

含义：当前这个类不能有任何的子类。(太监类)
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子）
*/

final class MyClass
{
    public void method()
    {
        System.out.println("方法执行！");
    }
}


//class MySubClass extends MyClass{} 错误写法

/*
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表)
{
	//方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
*/

class Person
{
    public void method1()
    {
        System.out.println("父类方法执行！");
    }
    
    public final void method2()
    {
        System.out.println("父类方法执行！");
    }
}

class Student extends Person
{
    @Override
    public void method1()
    {
        System.out.println("覆盖重写了父类方法");
    }
    
    //错误写法！不能覆盖重写父类当中final的方法
    /*
    @Override
    public void method1()
    {
        System.out.println("覆盖重写了父类方法");
    }
    */
}

/*
用来修饰局部变量
*/

class FinalExample
{
    public static void main(String[] args)
    {
        int num1 = 10;
        System.out.println(num1); //10
        num1 = 20;
        System.out.println(num1); //20
        
        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        //”一次赋值，终身不变“
        final int num2 = 200;
        System.out.println(num2); //200
        
        //num2 = 250; //错误写法！不能改变！
        
        //正确写法！只要保证有唯一一次赋值即可
        final int num3;
        num3 = 30;
        
        //对于基本类型来说，不可变说的是变量当中的数据不可改变
        //对于引用类型来说，不可变说的是变量当中的地址值不可改变
        
        Student stu1 = new Student();
        stu1 = new Student(); //内存地址发生了改变
        
        final Student stu2 = new Student();
        //stu2 = new Student(); //错误写法！final的引用类型变量，其中的地址不可改变
    }
}


/*
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
*/

class Hero
{
    private final String name;
    
    public Hero()
    {
        name = "Superman";
    }
    
    public Person(String name)
    {
        this.name = name;
    }
    
    public String getName()
    {
        return name;
    }
    
    //public void setName(String name)
    //{
    //    this.name = name;
    //}
}

四种权限修饰符

/*
Java中有四种权限修饰符：
                        public	   protected	   default	   private
同一个类(我自己)           Yes        Yes             Yes         Yes
同一个包(我邻居)           Yes        Yes             Yes         No
不同包子类(我儿子)          Yes        Yes             No          No
不同包非子类(陌生人)        Yes        No              No          No
*/

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
注意事项：

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
1. 抽象类不能创建对象，如果创建，便衣无法通过而报错。只能通过创建其非抽象子类的对象。
  
  理解：假设创建类抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2. 抽象类中，可以有构造方法，是提供子类创建对象时，初始化父类成员使用的。
  
  理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
  
  理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
  
  理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

/*
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前加上abstract即可。

如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后不上方法体大括号。
4. 创建子类对象进行使用。
*/
abstract class Animal
{
    //这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();
    
    public abstract void sleep();
    
    //这是普通的成员方法
    public void normalMethod()
    {
        
    }
}

class Cat extends Animal
{
    @Override
    public void eat()
    {
        System.out.println("猫吃鱼");
    }
}

abstract class Dog extends Animal
{
    
    @Override 
    public void eat()
    {
        System.out.println("狗吃骨头");
    }
    
    //public void sleep();
    
}

class DogGolden extends Dog
{
    @Override 
    public void sleep()
    {
        System.out.println("huhuhu");
    }
}

class Husky extends Dog
{
    @Override 
    public void sleep()
    {
        System.out.println("heiheihei");
    }
}

public class AbstractExample
{
    public static void main(String[] args)
    {
        Cat cat = new Cat();
        cat.eat(); //猫吃鱼
        
        //Dog dog = new Dog(); //错误
        
        Husky husky = new Husky();
        husky.eat();
        husky.sleep();
    }
}

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思路。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、Java、c#），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

/*
接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的抽象方法。

如何定义一个接口的格式：
public interface 接口名称
{
	// 接口内容
}

备注：如果换成了关键字interface之后，编译生成的字节码文件仍然是，.java-->.class

如果是Java 7，那么接口可以包含的内容有：
1. 常量
2. 抽象方法

如果是Java 8，还可以额外包含有：
3. 默认方法
4. 静态方法

如果是Java 9，还可以额外包含有，
5. 私有方法

接口使用步骤：
1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称
{
	//...
}
2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现，去掉abstract关键字，加上方法体大括号。
3.创建实现类的对象，进行使用。

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。



在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表);

注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略。
3. 方法的三要素，可以随意定义。
*/

interface MyInterfaceAbstract
{
    //这是一个抽象方法
    public abstract void methodAbs01();
    
    //这也是抽象方法
    abstract void methodAbs02();
    
    //这也是抽象方法
    public void methodAbs03();
    
    //这也是抽象方法
    void methodAbs04();
}

class MyInterfaceAbstractImpl implements MyInterfaceAbstract
{
    @Override
    public void methodAbs01
    {
        System.out.println("这是第一个方法！");
    }
    
    @Override
    public void methodAbs02
    {
        System.out.println("这是第二个方法！");
    }
    
    @Override
    public void methodAbs03
    {
        System.out.println("这是第三个方法！");
    }
    
    @Override
    public void methodAbs04
    {
        System.out.println("这是第四个方法！");
    }
}

public class InterfaceExample
{
    public static void main(String[] args)
    {
        //错误写法！不能直接new接口对象使用。
        //MyInterfaceAbstract inte = new MyInterfaceAbstract();
        
        //创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1(); //这是第一个方法
        impl.methodAbs2(); //这是第二个方法
    }
}

/*
从Java 8开始，接口允许定义默认方法。
格式：
public default 返回值类型 方法名称(参数列表) 
{
	//方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。
*/

interface MyInterfaceDefault
{
    //抽象方法
    public abstract void methodAbs01();
    
    //新添加了一个抽象方法
    //public abstract void methodAbs02();
    
    //新添加的方法，改成默认方法
    public default void methodDefault()
    {
        System.out.println("这是新添加的默认方法");
    }
}

/*
1. 接口的默认方法，可以通过接口实现类对象，直接调用。
2. 接口的默认方法，也可以被接口实现类进行覆盖重写。
*/

class MyInterfaceDefaultA implements MyInterfaceDefault
{
    @Override
    public void methodAbs()
    {
        System.out.println("实现了抽象方法 AAA");
    }
}

class MyInterfaceDefaultB implements MyInterfaceDefault
{
    @Override
    public void methodAbs()
    {
        System.out.println("实现了抽象方法 BBB");
    }
    
    @Override
    public void methodDefault()
    {
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}
public class InterfaceExample02
{
    public static void main(String[] args)
    {
        //创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); //调用抽象方法，实际运行的是右侧实现类
        
        //调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault();
        
        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); //实现类B覆盖重写了接口的默认方法
    }
}

/*
从Java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表)
{
	方法体
}
提示：就是将abstract或者default换成static即可，带上方法体。
*/

interface MyInterfaceStatic
{
    public static void methodStatic()
    {
        System.out.println("这是接口的静态方法！");
    }
}

/*
注意：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数);
*/

class MyInterfaceStaticImpl implements MyInterfaceStatic
{
    
}

public class InterfaceExample03
{
    public static void main(String[] args)
    {
        //创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        
        //错误写法！
        impl.methodStatic();
        
        //直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}

/*
问题描述：
我们需要抽取一个公有方法，用来解决两个默认方法之间重复代码的问题。
但是这个公有方法不应该让实现类使用，应该是私有化。

解决方案：
从Java 9开始，接口当中允许定义私有方法。
1. 普通私有方法，解决多个默认方法之间的重复代码问题
格式：
private 返回值类型 方法名称(参数列表)
{
	方法体
}

2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表)
{
	方法体
}
*/

interface MyInterfacePrivateA
{
    public default void methodDefault1()
    {
        System.out.println("默认方法1");
        //System.out.println("AAA");
        //System.out.println("BBB");
        //System.out.println("CCC");
        methodCommon();
    }
    
    public default void methodDefault2()
    {
        System.out.println("默认方法2");
        //System.out.println("AAA");
        //System.out.println("BBB");
        //System.out.println("CCC");
        methodCommon();
    }
    
    /*
    public default void methodCommon()
    {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
    */
    
    private void methodCommon()
    {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

class MyInterfacePrivateAImpl implements MyInterfacePrivateA
{
    public void methodAnother()
    {
        //直接访问到了接口中的默认方法，这样是错误的！
        //methodCommon();
    }
}

interface MyInterfacePrivateB
{
    public static void methodStatic1()
    {
        System.out.println("静态方法1");
        //System.out.println("AAA");
        //System.out.println("BBB");
        //System.out.println("CCC");
        methodStaticCommon();
    }
    
    public static void methodStatic2()
    {
        System.out.println("静态方法2");
        //System.out.println("AAA");
        //System.out.println("BBB");
        //System.out.println("CCC");
        methodStaticCommon();
    }
    
    /*
    public static void methodStaticCommon()
    {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
    */
    
    private static void methodStaticCommon()
    {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

public class InterfaceExample04
{
    public static void main(String[] args)
    {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();
        
        //错误写法！
        MyInterfacePrivateB.methodStaticCommon();
    }
}

/*
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这就是接口的【常量】
格式：
public static final 数据类型 常量名称 = 数据值；
注意：
一旦使用final关键字进行修饰，说明不可变。

注意事项：
1. 接口当中的常量，可以省略public static final, 注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值，不能不复制。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分割。(推荐命名规则)
*/

interface MyInterfaceConst
{
    //这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_CLASS = 10; 
}

public class InterfaceExample05
{)
    public static void main(String[] args)
    {
        //访问接口当中的常量
        System.out.println(MyInterfaceConst.NUM_OF_CLASS);
    }
}

在Java 9+版本中，接口的内容有：
1. 成员变量其实是常量，格式：
  
  [public] [static] [final] 数据类型常量名称 = 数据值;
  
  注意：
  - 常量必须进行赋值，而且一旦赋值不能改变。
  - 常量名称完全大写，用下划线进行分隔。
2. 接口中最重要的就是抽象方法，格式：
  
  [public] [abstract] 返回值类型方法名称(参数列表);
  
  注意：
  - 实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。
3. 从Java 8开始，接口里允许定义默认方法，格式：
  
  [public] default 返回值类型方法名称(参数列表) { 方法体 }
  
  注意：
  - 默认方法也可以被覆盖重写
4. 从Java 8开始，接口里允许定义静态方法，格式：
  
  [public] static 返回值类型方法名称(参数列表) { 方法体 }
  
  注意：
  - 应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
5. 从Java 9开始，接口里允许定义私有方法，格式：
  
  普通私有方法：private 返回值类型方法名称(参数列表) { 方法体 }
  
  静态私有方法：private static 返回值类型方法名称(参数列表) { 方法体 }
  
  注意：
  - private的方法只有接口自己才能调用，不能被实现类或别人使用。

/*
使用接口的时候，需要注意：

1. 接口是没有静态代码块或者构造方法的。
2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB
{
	//覆盖重写所有抽象方法
}
3. 如果实现类所实现的多个接口当中，存在重复
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5. 如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
*/

interface MyInterfaceA 
{
    //错误写法！接口不能有静态代码块
    /*
    static
    {
        
    }
    */
    
    //错误写法!接口不能有构造方法
    /*
    public MyInterfaceA()
    {
    
    }
    */
    
    public abstract void methodA();
    
    public abstract void methodAbs();
    
    public default void methodDefault()
    {
        System.out.println("默认方法AAA");
    }
}

interface MyInterfaceB 
{   
    public abstract void methodB();
    
    public abstract void methodAbs();
    
    public default void methodDefault()
    {
        System.out.println("默认方法AAA");
    }
}

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB
{
    public static void main(Strnig[] args)
    {
        @Override
        public void methodA()
        {
            System.out.println("覆盖重写了A方法");
        }
        
        @Override
        public void methodB()
        {
            System.out.println("覆盖重写了B方法");
        }
        
        @Override
        public void methodAbs()
        {
            System.out.println("覆盖重写了AB接口都有的抽象方法");
        }
        
        @Override
        public void default()
        {
            System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
        }
    }
}

abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB
{
        @Override
        public void methodA()
        {
            System.out.println("覆盖重写了A方法");
        }
        
        @Override
        public void methodB()
        {
            System.out.println("覆盖重写了B方法");
        }
    
        @Override
        public void default()
        {
            System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
        }
}

interface MyInterface
{
    public default void method()
    {
        System.out.println("接口的默认方法");
    }
}

class Person
{
    public void method()
    {
        System.out.println("父类方法");
    }
}

class Student extends Person implements MyInterface
{
    
}

/*
1. 类与类之间是单继承的。直接父类只有一个。
2. 类与接口之间是多实现的。一个类可以实现多个接口。
3. 接口与接口之间是多继承的。

注意事项：
1. 多个父接口当中的抽象方法如果重复，没关系。
2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。
*/

class RelationsExample
{
    
}

interface MyInterfaceA
{
    public abstract void methodA();
    
    public abstract void methodCommon();
    
    public default void methodDefault()
    {
        System.out.println("AAA");
    }
}

interface MyInterfaceB
{
    public abstract void methodB();
    
    public abstract void methodCommon();
    
    public default void methodDefault()
    {
        System.out.println("BBB");
    }
}
A
/*
这个子接口当中有几个方法？4个
methodA 来源于接口A
methodB 来源于接口B
methodCommon 同时来源于接口A和B
method 来源于我自己
*/
interface MyInterface extends MyInterfaceA, MyInterfaceB
{
    public abstract void method();
}

内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类类。
分类：
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类

/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：
1. 成员内部类
2. 局部内部类 (包含匿名内部类)

成员内部类的定义格式：
修饰符 class 外部类名称
{
	修饰符 class 内部类名称
	{
		//...
	}
	//...
}

注意：内用外，随意访问；外用内，需要内部类对象。


如何使用成员内部类？有两种方式：
1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2. 直接方式：公式
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
*/

class Body //外部类
{
    class Heart //成员内部类
    {
        //内部类方法
        public void beat()
        {
            System.out.println("心脏跳动");
            System.out.println("我叫" + name); //正确写法！
        }
    }
    
    //外部类的成员变量
    private String name;
    
    //外部类的方法
    public void methodBody()
    {
        System.out.println("外部类的方法");
        
        Heart heart = new Heart();
        heart.beat();
    }
}

public class InnerClassExample
{
    public static void main(String[] args)
    {
        //外部类对象
        Body body = new Body();
        
        //通过外部类的对象，调用外部类的方法，里面简介在使用内部类Heart
        body.methodBody();
        
        //按照公式写
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

//如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
class Outer
{
    int num = 10; //外部类的成员变量
    
    class Inner
    {
        int num = 20; //内部类的成员变量
        
        public void methodInner()
        {
            int num = 30; //内部类方法的局部变量
            System.out.println(num); //局部变量，就近原则
            System.out.println(this.num); //内部类的成员变量
            System.out.println(Outer.this.num); //外部类的成员变量
        }
    }
}

/*
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：
修饰符 class 外部类名称
{
	修饰符 返回值类型 外部类方法名称(参数列表)
	{
		class 局部内部类名称
		{
			//...
		}
	}
}

小节一下类的权限修饰符
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写
*/

class Outer
{
    public void methodOuter()
    {
        class Inner //局部内部类
        {
            int num = 10;
            public void methodInner()
            {
                System.out.println(num); //10
            }
        }
        
        Inner inner = new Inner();
        inner.methodInner();
    }
}

public class MainExample
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.methodOuter();
    }
}

/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：
1. new出来的对象在堆内存中。
2. 局部变量是跟着方法走的，局部变量就会立刻消失
3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
*/

class MyOuter
{
    public void methodOuter()
    {
        int num = 10; //所在方法的局部变量
        
        class MyInner
        {
            public void methodInner()
            {
                System.out.println(num)
            }
        }
    }
}

/*
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() 
{
	//覆盖重写所有抽象方法
}

对格式“new 接口名称() {...}”进行解析，
1. new 代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}这才是匿名内部类的内容

另外还有注意几点问题：
1. 匿名内部类：在创建对象的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2. 匿名对象：在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！
*/

interface MyInterface
{
    void method1();
    
    void method2();
}

class MyInterfaceImpl implements MyInterface
{
    @Override
    public void method1()
    {
        System.out.println("实现类覆盖重写了方法1");
    }
    
    @Override
    public void method2()
    {
        System.out.println("实现类覆盖重写了方法2");
    }
}

public class MainExample
{
    public static void main(String[] args)
    {
        //MyInterface obj = new MyInterfaceImpl();
        //obj.method();
        //MyInterface some = new MyInterface(); //错误写法！
        
        //使用匿名内部类，但不是匿名对象，对象名称就叫obj
        MyInterface obj = new MyInterface()
        {
            @Override
            public void method1()
            {
                System.out.println("匿名内部类实现了方法1！");
            }
            
             @Override
            public void method2()
            {
                System.out.println("匿名内部类实现了方法2！");
            }
        }
        
        obj.method1();
        
        //使用匿名内部类，而且省略了对象名称，也就是匿名对象
        new MyInterface()
        {
            @Override
            public void method1()
            {
                System.out.println("匿名内部类实现了方法1！");
            }
            
             @Override
            public void method2()
            {
                System.out.println("匿名内部类实现了方法2！");
            }
        }.method1();
        //因为匿名对象无法调用第二次方法，所以需要再创建一个匿名颞部类的匿名对象
        
        new MyInterface()
        {
            @Override
            public void method1()
            {
                System.out.println("匿名内部类实现了方法1！");
            }
            
             @Override
            public void method2()
            {
                System.out.println("匿名内部类实现了方法2！");
            }
        }.method2();
    }
}

class Weapon
{
    private String code; //武器的代号
    
    public Weapon()
    {
        
    }
    
    public Weapon(String code)
    {
        this.code = code;
    }
    
    public String getCode()
    {
        return code;
    }
    
    public void SetCode(String code)
    {
        this.code = code;
    }
}

interface Skill
{
    void use(); //释放技能的抽象方法
}

class SkillImpl implements Skill
{
    @Override
    public void use()
    {
        System.out.println("Biu~Biu~Biu");
    }
}

class Hero
{
    private String name; //英雄名字
    private int age; //英雄的年龄
    private Weapon weapon; //英雄的武器
    private Skill skill; //英雄的技能
    
    public Hero()
    {
        
    }
    
    public Hero(String name, int age, Weapon weapon, Skill skill)
    {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
        this.skill = skill;
    }
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
    
    public int getAge()
    {
        return age;
    }
    
    public void setName(int age)
    {
        this.age = age;
    }
    
    public Weapon getWeapon()
    {
        return weapon;
    }
    
    public void setWeapon(Weapon weapon)
    {
        this.weapon = weapon;
    }
    
    public Skill getSkill()
    {
        return skill;
    }
    
    public void setSkill(Skill skill)
    {
        this.skill = skill;
    }
}

public class GameExample
{
    public static void main(String[] args)
    {
        Hero hero = new Hero();
        hero.setName("Geollan");
        hero.setAge(20);
        
        //设置了武器
        Weapon weapon = new Weapon("Sword");
        hero.setWeapon(weapon)
            
        //设置了技能
        hero.setSkill(new SkillImpl); //使用单独定义的实现类
        
        //还可以改成使用匿名内部类
        Skill skill = new Skill()
        {
            @Override
            public void use()
            {
                System.out.println("Pia~Pia~Pia");
            }
        }
        
        //进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill()
                      {
                           @Override
                           public void use()
                           {
                               System.out.println("Bang~Pia~Bang");
                           }
                      }).use();
    }
}

import java.util.ArrayList;
import java.util.List;

/*
java.util.list正是ArrayList所实现的接口。
*/

public class InterfaceExample
{
    public static void main(String[] args)
    {
        //左边是接口名称，右边是实现类名称，这就是多态写法
        List<String> list = new ArrayList<>();
    
        List<String> result = addNames(list);
    
        for(int i = 0; i < result.size(); i++)
            System.out.println(result.get(i));
    }
    public static List<String> addNames(List<String> list)
    {
        list.add("George");
        list.add("Geollan");
        list.add("Davis");
    }
}

Geollan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java OOP

面向对象编程面向过程 & 面向对象面向过程思想步骤清晰简单，第一步做什么，第二部做什么…面对过程适合处理一些较为简单的问题面对对象思想物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理多人协作的问题！对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
复制链接

扫一扫