【狂神说Java】Java零基础学习笔记-面向对象

【狂神说Java】Java零基础学习笔记-面向对象

面向对象01：什么是面向对象

面向过程&面向对象

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

什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)
  
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
  
• 抽象：编程思想！持续的学习，茅塞顿开！多实践，多测试大脑中的想法！实践出真知~
  
• 三大特性：
  
  
  
  • 封装
    
  • 继承
    
  • 多态
    
  
  
• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
  
• 从代码运行角度考虑是先有类后有对象。类是对象的模板。
  

面向对象02：回顾方法的定义

回顾方法及加深

• 方法的定义
  
  
  
  • 修饰符
    
  • 返回类型
    
  • break：跳出switch，结束循环 和 return的区别
    
  • 方法名：注意规范就OK    见名知意
    
  • 参数列表：（参数类型，参数名）...
    
  • 异常抛出：疑问，后面讲解
    
  
  
• 方法的调用：递归
  
  
  
  • 静态方法
    
  • 非静态方法
    
  • 形参和实参
    
  • 值传递和引用传递
    
  • this关键字
    
  
  

1. package com.oop.demo01;
3. import java.io.IOError;
4. import java.io.IOException;
6. //Demo01 类
7. public class Demo01 {
8.     //main 方法
9.     public static void main(String[] args) {
11.     }
13.     /*
14.     修饰符 返回值类型 方法名(...){
15.         //方法体
16.         return 返回值;
17.     }
18.      */
19.     //return 结束方法，返回一个结果！
20.     public String sayHello(){
21.         return "hello,world";
22.     }
24.     public void print(){
25.         return;
26.     }
28.     public int max(int a,int b){
29.         return a>b ? a : b; //三元运算符！
30.     }
32.     //数组下标越界： Arrayindexoutofbounds
34.     public void readFile(String file) throws IOException{
35.         
36.     }
37. }

复制代码

面向对象03：回顾方法的调用

1. package com.oop.demo01;
3. public class Demo02 {
4.     public static void main(String[] args) {
5. //        //静态方法 static
6. //        Student.say();
8.         //非静态方法
9.         //实例化这个类 new
10.         //对象类型 对象名 = 对象值;
11.         Student student = new Student();
12.         student.say();
13.     }
15.     //static和类一起加载的
16.     public static void a(){
17.         //b();
18.     }
20.     //类实例化 之后才存在
21.     public void b(){
23.     }
24. }
26. 学生说话了

复制代码

1. package com.oop.demo01;
3. //学生类
4. public class Student {
5. //    //静态方法
6. //    public static void say(){
7. //        System.out.println("学生说话了");
8. //    }
10.     //非静态方法
11.     public void say(){
12.         System.out.println("学生说话了");
13.     }
14. }

复制代码

1. package com.oop.demo01;
3. public class Demo03 {
4.     public static void main(String[] args) {
5.         //实际参数和形式参数的类型要对应！
6.         int add = Demo03.add(1,2);
7.         System.out.println(add);
8.     }
10.     public static int add(int a,int b){
11.         return a+b;
12.     }
13. }
15. 3

复制代码

1. package com.oop.demo01;
3. //值传递
4. public class Demo04 {
5.     public static void main(String[] args) {
6.         int a = 1;
7.         System.out.println(a); //1
9.         Demo04.change(a);
10.         System.out.println(a); //1
11.     }
13.     //返回值为空
14.     public static void change(int a){
15.         a = 10;
16.     }
17. }
19. 1
20. 1

复制代码

1. package com.oop.demo01;
3. //引用传递：对象
5. //对象，内存！
7. public class Demo05 {
8.     public static void main(String[] args) {
9.         Perosn perosn = new Perosn();
10.         System.out.println(perosn.name); //null
12.         Demo05.change(perosn);
13.         System.out.println(perosn.name); //黎明の微笑
14.     }
16.     public static void change(Perosn perosn){
17.         //perosn是一个对象，指向的--->Perosn perosn = new Perosn(); 这是一个具体的人，可以改变属性！
18.         perosn.name = "黎明の微笑";
19.     }
20. }
22. //定义了一个Perosn类，有一个属性：name
23. class Perosn{
24.     String name; //null
25. }
27. null
28. 黎明の微笑

复制代码

面向对象04：类与对象的创建

类与对象的关系

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

我们可以将这些思想转换为代码实现!
创建与初始化对象

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

1. package com.oop.demo02;
3. //学生类
4. public class Student {
5.     //属性：字段
6.     String name; //null
7.     int age; //0
9.     //方法
10.     public void study(){
11.         System.out.println(this.name+"在学习");
12.     }
13. }
15. //Person ---> 身高，体重，年龄，国家
16. //学程序好？对世界进行更好的建模！ --->宅！ --->音乐，旅游，出国！

复制代码

1. package com.oop.demo02;
3. //一个项目应该只存一个main方法
4. public class Application {
5.     public static void main(String[] args) {
6.         //类：抽象的，实例化
7.         //类实例化后会返回一个自己的对象！
8.         // student对象就是一个student类的具体实例！
10.         Student xiaoming = new Student();
11.         Student xh = new Student();
13.         xiaoming.name = "小明";
14.         xiaoming.age = 3;
16.         System.out.println(xiaoming.name);
17.         System.out.println(xiaoming.age);
19.         xh.name = "小红";
20.         xh.age = 3;
22.         System.out.println(xh.name);
23.         System.out.println(xh.age);
24.     }
25. }
27. 小明
28. 3
29. 小红
30. 3

复制代码

面向对象05：构造器详解

1. package com.oop.demo02;
3. //java ---> class
4. public class Person {
5.     //一个类即使什么都不写，它也会存在一个方法
6.     //显示的定义构造器
7.     String name;
8.     int age;
10.     //alt + insert
12.     //实例化初始值
13.     //1.使用new关键字，本质是在调用构造器
14.     //2.用来初始化值
15.     public Person(){
17.     }
19.     //有参构选：一旦定义了有参构造，无参就必须显示定义
20.     public Person(String name){
21.         this.name = name;
22.     }
24.     public Person(String name, int age) {
25.         this.name = name;
26.         this.age = age;
27.     }
28. }
30. /*
31.     public static void main(String[] args) {
32.         //new 实例化了一个对象
33.         Person person = new Person("liming",23);
35.         System.out.println(person.name); //liming
36.     }
37. */
39. /*
40. 构造器:
41.     1.和类名相同
42.     2.没有返回值
43. 作用:
44.     1.new本质在调用构造方法
45.     2.初始化对象的值
46. 注意点:
47.     1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
49. ALt + Insert
51. this. =
52. */

复制代码

面向对象06：创建对象内存分析

1. package com.oop.demo03;
3. public class Pet {
4.     public String name;
5.     public int age;
7.     //无参构造
9.     public void shout(){
10.         System.out.println("叫了一声");
11.     }
12. }
14. /*
15.     public static void main(String[] args) {
16.         Pet dog = new Pet();
18.         dog.name = "旺财";
19.         dog.age = 3;
20.         dog.shout();
22.         System.out.println(dog.name);
23.         System.out.println(dog.age);
25.         Pet cat = new Pet();
26.     }
27. */

复制代码

面向对象07：简单小结类与对象

1. /*
2. 1.类与对象
3.         类是一个模板：抽象，对象是一个具体的实例
4. 2.方法
5.         定义、调用!
6. 3.对应的引用
7.         引用类型：        基本类型（8）
8.         对象是通过引用来操作的：栈 ---> 堆
9. 4.属性：字段 Field 成员变量
10.         默认初始化:
11.                 数字：0        0.0
12.                 char：u0000
13.                 boolean：false
14.                 引用：nuLL
15.         修饰符 属性类型 属性名 = 属性值！
16. 5.对象的创建和使用
17.         - 必须使用 new 关键字创造对象，构造器 Person kuangshen = new Person();
18.         - 对象的属性 kuangshen.name
19.         - 对象的方法 kuangshen.sleep()
20. 6.类
21.         静态的属性 属性
22.         动态的行为 方法
24. `封装、继承、多态`
25. */

复制代码

面向对象08：封装详解

封装

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

1. package com.oop.demo04;
3. //类     private：私有
4. public class Student {
5.     //属性私有
6.     private String name; //名字
7.     private int id; //学号
8.     private char sex; //性别
9.     private int age; //年龄
11.     //提供一些可以操作这个属性的方法！
12.     //提供一些 public 的 get、set 方法
14.     //get 获得这个数据
15.     public String getName(){
16.         return this.name;
17.     }
19.     //set 给这个数据设置值
20.     public void setName(String name){
21.         this.name = name;
22.     }
24.     //alt + insert
26.     public int getId() {
27.         return id;
28.     }
30.     public void setId(int id) {
31.         this.id = id;
32.     }
34.     public char getSex() {
35.         return sex;
36.     }
38.     public void setSex(char sex) {
39.         this.sex = sex;
40.     }
41.    
42.     public int getAge() {
43.         return age;
44.     }
46.     public void setAge(int age) {
47.         if (age>120 || age<0){ //不合法
48.             this.age = 3;
49.         }else {
50.             this.age = age;
51.         }
52.     }
53. }
55. /*
56. 1. 提高程序的安全性，保护数据
57. 2. 隐藏代码的实现细节
58. 3. 统一接口
59. 4. 系统可维护增加了
60. */
62. /*
63.     public static void main(String[] args) {
64.         Student s1 = new Student();
66.         s1.setName("黎明の微笑");
67.         System.out.println(s1.getName());
69.         s1.setAge(-1); //不合法的
70.         System.out.println(s1.getAge());
71.     }
72. */

复制代码

1. package com.oop.demo05;
3. //在Java中，所有的类，都默认直接或者间接继承Object
4. //Person 人 ： 父类
5. public class Person /*extends Object*/ {
6.     //public
7.     //protected
8.     //default
9.     //private
10.     private int money = 10_0000_0000;
12.     public void say(){
13.         System.out.println("说了一句话");
14.     }
16.     public int getMoney() {
17.         return money;
18.     }
20.     public void setMoney(int money) {
21.         this.money = money;
22.     }
23. }
25. /*
26. ctrl + H 树
27. */
29. /*
30.     public static void main(String[] args) {
32.         Person person = new Person();
34.         Student student = new Student();
35.         student.say();
36.         System.out.println(student.getMoney());
37.     }
38. */

复制代码

1. package com.oop.demo05;
3. //Student is 人 ： 派生类，子类
4. //子类继承了父类，就会拥有父类的全部方法！
5. public class Student extends Person {
6. }

复制代码

面向对象10：Super详解

super注意点:

• super 调用父类的构造方法，必须在构造方法的第一个
  
• super 必须只能出现在子类的方法或者构造方法中!
  
• super 和 this不能同时调用构造方法!
  

Vs this:
代表的对象不同:
​        this:本身调用者这个对象
​        super:代表父类对象的应用
前提
​        this:没哟继承也可以使用
​        super:只能在继承条件才可以使用
构造方法
​        this();本类的构造
​        super();父类的构造!

1. package com.oop.demo05;
3. //Teacher is 人 ： 派生类，子类
4. public class Teacher extends Person {
5. }

复制代码

1. package com.oop.demo05;
3. public class Person /*extends Object*/ {
4.     public Person() {
5.         System.out.println("Person无参执行了");
6.     }
8. //    public Person(String name) {
9. //        System.out.println("Person有参执行了");
10. //    }
12.     protected String name = "liming";
14.     //私有的东西无法被继承！
15.     public void print(){
16.         System.out.println("Person");
17.     }
19. }
21. /*
22.     public static void main(String[] args) {
23.         Student student = new Student();
25.         //student.test1();
27.         //student.test("微笑");
29.     }
30. */

复制代码

面向对象11：方法重写

重写:需要有继承关系，子类重写父类的方法!
​        1．方法名必须相同
​        2．参数列表列表必须相同
​        3．修饰符:范围可以扩大但不能缩小: public>Protected>Default>private
​        4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException ---> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!
为什么需要重写:
​        1．父类的功能，子类不一定需要，或者不一定满足!Alt + Insert ; override;

1. package com.oop.demo05;
3. public class Student extends Person {
4.     public Student() {
5.         //隐敲代码：调川了父类的无参构选
6.         super(); //调用父类的构造器，必须要在子类构造器的第一行
7.         //this("hello");
8.         System.out.println("Student无参执行了");
10. //        super("name");
11. //        System.out.println("Student有参执行了");
12.     }
14.     public Student(String name) {
15.         this.name = name;
16.     }
18.     private String name = "weixiao";
20.     public void print(){
21.         System.out.println("Student");
22.     }
24. //    public void test1(){
25. //        print(); //Student
26. //        this.print(); //Student
27. //        super.print(); //Person
28. //    }
30. //    public void test(String name){
31. //        System.out.println(name); //微笑
32. //        System.out.println(this.name); //weixiao
33. //        System.out.println(super.name); //liming
34. //    }
35. }

复制代码

1. package com.oop.demo05;
3. //重写都是方法的重写，和属性无关
4. public class B {
5. //    public static void test(){
6. //        System.out.println("B=>test()");
7. //    }
9.     public void test(){
10.         System.out.println("B=>test()");
11.     }
12. }
14. /*
15.     //静态的方法和非静态的方法区别很大！
16.         //静态方法：//方法的调用只和左边，定义的数据类型有关
17.     //非静态：重写
19.     public static void main(String[] args) {
20.         A a = new A();
21.         a.test(); //A
23.         //父类的引川指向了子类
24.         B b = new A(); //子类重写了父类的方法
25.         b.test(); //B
26.     }
27. */

复制代码

面向对象12：什么是多态

多态

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

1. package com.oop.demo05;
3. //继承
4. public class A extends B {
5. //    public static void test(){
6. //        System.out.println("A=>test()");
7. //    }
9.     //Override 重写
10.     @Override //注解：有功能的注释！
11.     public void test() {
12.         System.out.println("A=>test()");
13.     }
14. }

复制代码

1. package com.oop.demo06;
3. public class Person {
4.     public void run(){
5.         System.out.println("run");
6.     }
7. }
9. /*
10. 多态注意事项:
11. 1. 多态是方法的多态，属性没有多态
12. 2. 父类和子类，有联系类型转换异常! ClassCastException!
13. 3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
15.     1. static 静态方法，属于类，它不属于实例
16.     2. final 常量；
17.     3. private 私有方法；
18. */
20. /*
21.     public static void main(String[] args) {
22.         //一个对象的实际类型是确定的
23.         //new Student();
24.         //new Person();
26.         //可以指向的引川类型就不确定了：父类的引用指向子类
28.         //Student 子类型，能调用的方法都是自己的或者然承父类的!
29.         Student s1 = new Student();
30.         //Person 父类型，可以指向了类，但是不能调用子类独有的方法
31.         Person s2 = new Student();
32.         Object s3 = new Student();
34.         //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
35.         s2.run(); //子类重写了父类的方法，执行子类的方法
36.         s1.run();
38.         //s2.eat();
39.         ((Student) s2).eat();
40.         s1.eat();
41.     }
42. */

复制代码

面向对象13：instanceof和类型转换

1. package com.oop.demo06;
3. public class Student extends Person {
4.     @Override
5.     public void run() {
6.         System.out.println("son");
7.     }
9.     public void eat(){
10.         System.out.println("eat");
11.     }
12. }

复制代码

1. package com.oop.demo06;
3. public class Person {
4.     public void run(){
5.         System.out.println("run");
6.     }
7. }
9. /*
10.     public static void main(String[] args) {
11.         //Object > Person > Student
12.         //Object > Person > Teacher
13.         //Object > String
15.         //System.out.println(X instanceof Y); //能不能编译通过！
17.         Object object = new Student();
18.         System.out.println(object instanceof Student); //true
19.         System.out.println(object instanceof Person); //true
20.         System.out.println(object instanceof Object); //true
21.         System.out.println(object instanceof Teacher); //false
22.         System.out.println(object instanceof String); //false
23.         System.out.println("====================");
25.         Person person = new Student();
26.         System.out.println(person instanceof Student); //true
27.         System.out.println(person instanceof Person); //true
28.         System.out.println(person instanceof Object); //true
29.         System.out.println(person instanceof Teacher); //false
30.         //System.out.println(person instanceof String); //编译报错！
31.         System.out.println("====================");
33.         Student student = new Student();
34.         System.out.println(student instanceof Student); //true
35.         System.out.println(student instanceof Person); //true
36.         System.out.println(student instanceof Object); //true
37.         //System.out.println(student instanceof Teacher); //编译报错！
38.         //System.out.println(student instanceof String); //编译报错！
39.     }
40. */
42. /*
43.     public static void main(String[] args) {
44.         //类型之间的转化：父     子
46. //        //高                  低
47. //        Person obj = new Student();
48. //
49. //        //student将这个对象转换为Student类型，我们就可以使川Student类型的方法了！
50. //        Student student = (Student) obj;
51. //        student.go();
52. //        //((Student) obj).go();
54.         //子类转换为父类，可能丢失自己的本来的一些方法！
55.         Student student = new Student();
56.         student.go();
57.         Person person = student;
58.     }
59. */
61. /*
62. 1. 父类引用指向子类的对象
63. 2. 把子类转换为父类，向上转型;
64. 3. 把父类转换为子类，向下转型; 强制转换
65. 4. 方便方法的调用，减少重复的代码！简介
67. 封装、继承、多态！   抽象类，接口
68. */

复制代码

1. package com.oop.demo06;
3. public class Student extends Person {
4.     public void go(){
5.         System.out.println("go");
6.     }
7. }

复制代码

面向对象14：static关键字详解

1. package com.oop.demo06;
3. public class Teacher extends Person {
5. }

复制代码

1. package com.oop.demo07;
3. //static
4. public class Student {
5.     private static int age; //静态的变量     多线程！
6.     private double score; //非静态的变量
8.     public void run(){
10.     }
12.     public static void go(){
14.     }
16.     public static void main(String[] args) {
17. //        Student s1 = new Student();
18. //
19. //        System.out.println(Student.age);
20. //        //System.out.println(Student.score);
21. //        System.out.println(s1.age);
22. //        System.out.println(s1.score);
24.         //run();
25.         go();
26.     }
27. }

复制代码

1. package com.oop.demo07;
3. public class Person {
4.     //2：赋初值~
5.     {
6.         //代码块（匿名代码块）
7.         System.out.println("匿名代码块");
8.     }
11.     //1：只执行一次~
12.     static {
13.         //静态代码块
14.         System.out.println("静态代码块");
15.     }
17.     //3
18.     public Person() {
19.         System.out.println("构造方法");
20.     }
22.     public static void main(String[] args) {
23.         Person person1 = new Person();
24.         System.out.println("====================");
25.         Person person2 = new Person();
26.     }
27. }
29. 静态代码块
30. 匿名代码块
31. 构造方法
32. ====================
33. 匿名代码块
34. 构造方法

复制代码

面向对象15：抽象类

抽象类

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

1. package com.oop.demo07;
3. //静态导入包~
4. import static java.lang.Math.random;
5. import static java.lang.Math.PI;
7. public class Test {
8.     public static void main(String[] args) {
9.         System.out.println(random());
10.         System.out.println(PI);
11.     }
12. }

复制代码

1. package com.oop.demo08;
3. //abstract 抽象类：类 extends    单继承~    （接口可以多继承）
4. public abstract class Action {
5.     //约束~有人帮我们实现~
6.     //abstract 抽象方法，只有方法名字，没有方法的实现！
7.     public abstract void doSomething();
9.     //1. 不能new这个抽象类，只能靠子类去实现它；约束！
10.     //2. 抽象类中可以写普通的方法~
11.     //3. 抽象方法必须在抽象类中~
12.     //抽象的抽象：约束~
14.     //思考题?
15.     //new，存在构造器么? （存在）
16.     //抽象类存在的意义      抽象出来~       提高开发效率
17. }

复制代码

面向对象16：接口的定义与实现

接口

• 普通类:只有具体实现
  
• 抽象类:具体实现和规范(抽象方法)都有!
  
• 接口:只有规范!自己无法写方法专业的约束！约束和实现分离：面向接口编程
  
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能…”的思想。如果你是天使,则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。
  
• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
  
• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
  

声明类的关键字是class,声明接口的关键字是interface

1. package com.oop.demo08;
3. //抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非子类也是抽象的（abstract）~
4. public class A extends Action {
5.     @Override
6.     public void doSomething() {
8.     }
9. }

复制代码

1. 作用:
2.     1. 约束
3.     2. 定义一些方法，让不同的人实现~ 10 ---> 1
4.     3. public abstract
5.     4. public static final
6.     5. 接口不能被实例化~，接口中没有构造方法~
7.     6. implements可以实现多个接口
8.     7. 必须要重写接口中的方法~
9.     8. 总结博客~

复制代码

1. package com.oop.demo09;
3. //抽象的思维~ Java 架构师~
5. //interface 定义的关键字 , 接口都需要有实现类
6. public interface UserService {
7.     //常量~ public static final
8.     int AGE = 99;
10.     //接口中的所有定义的方法其实都是抽象的 public abstract
11.     void add(String name);
12.     void delete(String name);
13.     void update(String name);
14.     void query(String name);
15. }

复制代码

1. package com.oop.demo09;
3. //抽象类：extends~
4. //类 可以实现接口 implements 接口
5. //父现了接口的类，就需要重写接口中的方法~
7. //多继承~利用接口实现多继承~
8. public class UserServiceImpl implements UserService,TimeService {
9.     @Override
10.     public void add(String name) {
12.     }
14.     @Override
15.     public void delete(String name) {
17.     }
19.     @Override
20.     public void update(String name) {
22.     }
24.     @Override
25.     public void query(String name) {
27.     }
29.     @Override
30.     public void timer() {
32.     }
33. }

复制代码

面向对象17：N种内部类

内部类

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
  
• 1.成员内部类
  
• 2.静态内部类
  
• 3.局部内部类
  
• 4.匿名内部类
  

1. package com.oop.demo09;
3. public interface TimeService {
4.     void timer();
5. }

复制代码

1. package com.oop.demo10;
3. public class Outer {
4.     private int id=10;
6.     public void out(){
7.         System.out.println("这是外部类的方法");
8.     }
10.     public class Inner{
11.         public void in(){
12.             System.out.println("这是内部类的方法");
13.         }
15.         //获得外部类的私有属性~
16.         public void getID(){
17.             System.out.println(id);
18.         }
19.     }
21.     //局部内部类
22.     public void method(){
23.         class Inner{
24.             public void in(){
26.             }
27.         }
28.     }
29. }
31. //一个java类中可以有多个class类，但是只能有一个public class
32. class A{
33.     public static void main(String[] args) {
35.     }
36. }
38. /*
39.     public static void main(String[] args) {
40.         //new
41.         Outer outer = new Outer();
43.         //通过这个外部类来实例化内部类~
44.         Outer.Inner inner = outer.new Inner();
45.         inner.in();
46.         inner.getID();
47.     }
48. */

复制代码

【【狂神说Java】Java零基础学习视频通俗易懂】https://www.bilibili.com/video/BV12J41137hu?p=60&vd_source=fd5defd6aaa826e3b6e0c06073353e32


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！