• JAVA 面向对象（OOP）

    1.什么是面向对象？

    2.面向过程与面向对象的区别

    3.回顾方法的定义

    • break和return的区别

     跳出switch，结束循环和return的区别

    •  方法名: 注意规范。驼峰命名法。
    • 参数列表
    • 异常抛出

    4.回顾方法的调用

    • 静态方法
    • 非静态方法
    • 形参和实参
    • 值传递和引用传递
    • this 关键字

    5.类与对象的创建

     使用new关键字创建对象

    使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

    类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    1、必须和类的名字相同
    2、必须没有返回类型，也不能写void

    1. package org.psmaxwell.oop.demo02;
    2. //学生类
    3. public class Student {
    4.     //属性： 字段
    5.     String name; //null
    6.     int age;    //0
    7.  
    8.     //方法
    9.     public void study(){
    10.         System.out.println(this.name +"在学习");
    11.     }
    12.  
    13. }
    14.  
    15. /**
    16.  *     public static void main(String[] args) {
    17.  *
    18.  *
    19.  *         // 类： 抽象的， 实例化
    20.  *         // 类实例化后会返回一个自己的对象！
    21.  *         //student 对象就是一个Student类的具体实例！
    22.  *         Student xiaoming = new Student();
    23.  *         Student xh = new Student();
    24.  *
    25.  *         xiaoming.name = "小明";
    26.  *         xiaoming.age = 3;
    27.  *
    28.  *         System.out.println(xiaoming.name);
    29.  *         System.out.println(xiaoming.age);
    30.  *
    31.  *         xh.name = "小红";
    32.  *         xh.age = 3;
    33.  *
    34.  *         System.out.println(xh.name);
    35.  *         System.out.println(xh.age);
    36.  *
    37.  *     }
    38.  */

    6.构造器详解

    1. package org.psmaxwell.oop.demo03;
    2.  
    3. public class Pet {
    4.     public String name;
    5.     public int age;
    6.  
    7.     //无参构造
    8.  
    9.     public void shout(){
    10.         System.out.println("叫了一声");
    11.     }
    12.  
    13. }
    14.  
    15.  
    16. /**
    17.  *
    18.  Pet dog = new Pet();
    19.  dog.name = "旺财";
    20.  dog.age = 3;
    21.  dog.shout();
    23.  System.out.println(dog.name);
    24.  System.out.println(dog.age);
    25.  */

    7.简单小结类与对象

          
            1.类是一个模板，对象是一个具体的实例。
            2.方法
            定义、调用！
            3.对应的引用
            引用类型： 基本类型
            对象是通过引用来操作的，栈---》堆

            4.属性： 字段Field 成员变量
            默认初始化
            数字 ： 0     0.0
            char : u0000
            boolean : false
            引用 ： null

            修饰符 属性类型 属性名 = 属性值！

            5.对象的创建和使用
            - 必须使用new 关键字创造对象，构造器 Person Maxwell = new Person();
            - 对象的属性 Maxwell.name
            - 对象方法  Maxwell.sleep()

            6.类
               静态的属性    属性
               动态的行为    方法

               封装、继承、多态

     8.封装详解

        该露的露，该藏的藏
       我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成。不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。     

    封装（数据的隐藏）
    通常，应禁止直接访问一个对象中数据的实际标识，而应通过操作接口来访问，这称为信息隐藏。

    1. 记住这句话就够了：属性私有，get/set
    2.  
    3. package org.psmaxwell.oop.Demo04;
    4. //类  private： 私有
    5. public class Student {
    6.  
    7.     //属性私有
    8.     private String name;  //名字
    9.     private  int id;    //学号
    10.     private char sex;  //性别
    11.     private int age;
    12.  
    13.     //提供一些可以操作这个属性的方法
    14.     // 提供一些public的get、set的方法
    15.     //get 获得这个数据
    16.     public String getName(){
    17.         return this.name;
    18.     }
    19.     // set 给这个数据设置值
    20.     public void setName(String name){
    21.         this.name=name;
    22.     }
    23.     //alt + Insert
    24.  
    25.     public int getId() {
    26.         return id;
    27.     }
    28.  
    29.     public void setId(int id) {
    30.         this.id = id;
    31.     }
    32.  
    33.     public char getSex() {
    34.         return sex;
    35.     }
    36.  
    37.     public void setSex(char sex) {
    38.         this.sex = sex;
    39.     }
    40.  
    41.     public int getAge() {
    42.         return age;
    43.     }
    44.  
    45.     public void setAge(int age) {
    46.         if(age>120 || age<0) {
    47.             this.age = 3;
    48.         }else{
    49.             this.age = age;
    50.         }
    51.     }
    52. }
    53.  
    54. /**
    55.  * 
    56.  *         Student s1 = new Student();
    57.  *
    58.  *         s1.setName("Maxwell");
    59.  *
    60.  *         System.out.println(s1.getName());
    61.  *
    62.  *         s1.setAge(999);  //不合法
    63.  *
    64.  *         System.out.println(s1.getAge());
    65.  */

    9.什么是继承？

     10.Super详解

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


    Super Vs this:
    代表的对象不同：
    this ： 本身调用者这个对象
    super:  代表父类对象的应用

    前提：
    this : 没有继承也可以使用
    super: 只能在继承条件下才可以使用

    构造方法：
    this() : 本类构造器。
    super() : 父类构造器！

    1. package org.psmaxwell.oop;
    2.  
    3. import org.psmaxwell.oop.demo05.Person;
    4. import org.psmaxwell.oop.demo05.Student;
    5.  
    6. // 一个项目应该只存在一个main方法
    7. public class Application {
    8.     public static void main(String[] args) {
    9.  
    10.         Student student = new Student();
    11.        // student.test("小山");
    12.        // student.test1();
    13.     }
    14. }
    1. package org.psmaxwell.oop.demo05;
    2.  
    3. // 学生 is 人   子类 派生类
    4. // 子类继承了父类，就会拥有父类的全部方法
    5. public class Student extends Person {
    6.  
    7.     public Student() {
    8.         //隐藏代码：调用了父类的无参构造
    9.         super();//调用父类的构造器，必须要在子类构造器的第一行。
    10.         System.out.println("Student无参构造执行了");
    11.     }
    12.  
    13.     //Ctrl + H
    14.     private String name = "xiaoshan";
    15.  
    16.     public void print(){
    17.         System.out.println("Student");
    18.     }
    19.  
    20.     public void test1(){
    21.         print();  //Student
    22.         this.print();  //Student
    23.         super.print();  //Person
    24.     }
    25.     public void test2(String name){
    26.         System.out.println(name); // 小山 main
    27.         System.out.println(this.name); //调用子类
    28.         System.out.println(super.name); //调用父类
    29.     }
    30. }
    1. package org.psmaxwell.oop.demo05;
    2. //Person is 人   父类
    3. //在Java中，所有的类，都默认直接或者间接继承Object
    4. public class Person /*extends Object*/{
    5.  
    6.     public Person() {
    7.         System.out.println("Person无参执行了");
    8.     }
    9.  
    10.     protected  String name = "Maxwell";
    11.  
    12.     //私有的东西无法被继承
    13.     public void print(){
    14.         System.out.println("Person");
    15.     }
    16. }

    11.方法重写

    ---重写

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

    为什么需要重写？
    1.父类的功能，子类不一定需要，或者不一定满足。
    Alt + Insert :overwrite;

    1. package org.psmaxwell.oop;
    2.  
    3. import org.psmaxwell.oop.demo05.A;
    4. import org.psmaxwell.oop.demo05.B;
    5.  
    6. //静态的方法和非静态方法区别很大！
    7.  
    8. //非静态： 重写
    9.  
    10. public class Application {
    11.     public static void main(String[] args) {
    12.  
    13.         // 静态方法： //方法的调用只和左边，定义的数据类型有关
    14.         A a = new A();
    15.         a.test();   //A
    16.  
    17.         //父类的引用指向子类
    18.         B b = new A();  //子类重写了父类的方法
    19.         b.test();  //B
    20.     }
    21. }
    1. package org.psmaxwell.oop.demo05;
    2. //继承
    3. public class A extends B{
    4.  
    5.  
    6.     //重写
    7.     @java.lang.Override   //注解
    8.     public void test() {
    9.         System.out.println("A=>test()");
    10.     }
    11. }
    1. package org.psmaxwell.oop.demo05;
    2. //重写都是方法的重写，与属性无关
    3. public class B {
    4.     public  void test(){
    5.         System.out.println("B=>test()");
    6.     }
    7. }

    12.instanceof和类型转换

    1. package org.psmaxwell.oop;
    2.  
    3. import org.psmaxwell.oop.demo06.Person;
    4. import org.psmaxwell.oop.demo06.Student;
    5. import org.psmaxwell.oop.demo06.Teacher;
    6.  
    7. public class Application {
    8.     public static void main(String[] args) {
    9.  
    10.         //类型之间的转换     父                子
    11.         //高                    低
    12.         Person obj = new Student();
    13.  
    14.         //student 将这个对象转换为Student类型，我们就可以使用Student类型的方法了。
    15.         // 子类转父类可能丢失自己的本来的一些方法！
    16. //        Student student = (Student) obj;
    17. //        student.go();
    18.         ((Student) obj).go();
    19.  
    20. /**
    21.  * 1.父类的引用执行子类的对象
    22.  * 2.把子类转换为父类，向上转型
    23.  * 3.把父类转换为子类，向下转型，强制转换。
    24.  * 4.方便方法的调用，减少重复的代码，简洁
    25.  *
    26.  * 封装、继承、多态、接口
    27.  * 多实践、多测试、实践出真知。
    28.  * 
    29.  *
    30.  */
    31.     }
    32. }
    1. package org.psmaxwell.oop.demo06;
    2.  
    3. public class Person {
    4.  
    5.     public void run(){
    6.         System.out.println("run");
    7.     }
    8. }
    1. package org.psmaxwell.oop.demo06;
    2.  
    3. public class Student extends Person {
    4.     public void go(){
    5.         System.out.println("go");
    6.     }
    7. }
    8.  
    9. /**
    10.  *
    11.  * public class Student extends Person {
    12.  *
    13.  *     @java.lang.Override
    14.  *     public void run() {
    15.  *         System.out.println("son");
    16.  *     }
    17.  *
    18.  *     public void eat(){
    19.  *         System.out.println("eating");
    20.  *     }
    21.  * }
    22.  *
    23.  *
    24.  *
    25.  */
    26.  
    27. /**
    28.  *
    29.  *    // Object > String
    30.  *         // Object > Person > Teacher
    31.  *         // Object > Person > Student
    32.  *         Object object = new Student();
    33.  *
    34.  *         //System.out.println(x instanceof y); //能不能通过
    35.  *
    36.  *         System.out.println(object instanceof Student); //true
    37.  *         System.out.println(object instanceof Person);  //true
    38.  *         System.out.println(object instanceof Object);  //true
    39.  *         System.out.println(object instanceof Teacher); //false
    40.  *         System.out.println(object instanceof String); //false
    41.  *
    42.  *         System.out.println("==========================");
    43.  *
    44.  *         Person person = new Student();
    45.  *
    46.  *         System.out.println(person instanceof Student); //true
    47.  *         System.out.println(person instanceof Person);  //true
    48.  *         System.out.println(person instanceof Object);  //true
    49.  *         System.out.println(person instanceof Teacher); //false
    50.  *        // System.out.println(person instanceof String); //编译报错
    51.  *
    52.  *
    53.  *         System.out.println("==========================");
    54.  *
    55.  *         Student student = new Student();
    56.  *
    57.  *         System.out.println(student instanceof Student); //true
    58.  *         System.out.println(student instanceof Person);  //true
    59.  *         System.out.println(student instanceof Object);  //true
    60.  *         //System.out.println(student instanceof Teacher); //编译报错
    61.  *         //System.out.println(student instanceof String); //编译报错
    62.  */

    13.static关键字详解

    1. package org.psmaxwell.oop.demo07;
    2. //静态导入包
    3. import static java.lang.Math.random;
    4. import static java.lang.Math.PI;
    5.  
    6. public class Test {
    7.     public static void main(String[] args) {
    8.         System.out.println(Math.random());
    9.         System.out.println(PI);
    10.     }
    11. }
    1. package org.psmaxwell.oop;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.  
    6.     }
    7. }
    1. package org.psmaxwell.oop.demo07;
    2. //static
    3. public class Student {
    4.  
    5.     private static int age;   //静态的变量
    6.     private double score;    //非静态变量
    7.  
    8.     public void run(){
    9.         go();
    10.  
    11.     }
    12.  
    13.     public static void go(){
    14.  
    15.     }
    16.  
    17.     public static void main(String[] args) {
    18.         Student.go();
    19.  
    20.     }
    21. }
    1. package org.psmaxwell.oop.demo07;
    2.  
    3. public class Person {
    4.  
    5. //2
    6.     {
    7.         //代码块（匿名代码块）
    8.         System.out.println("匿名代码块");
    9.     }
    10. // 1  只执行一次
    11.     static {
    12.         //静态代码块
    13.         System.out.println("静态代码块");
    14.     }
    15. //3
    16.     public Person() {
    17.         System.out.println("构造方法");
    18.     }
    19.  
    20.     public static void main(String[] args) {
    21.         Person person = new Person();
    22.         System.out.println("==========================");
    23.         Person person2 = new Person();
    24.     }
    25. }

    14.抽象类

    • abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。
    • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
    • 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
    • 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
    • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
    1. package org.psmaxwell.oop.demo08;
    2. //abstract 抽象类  类 extends: 单继承   （接口可以多继承）
    3. public abstract class Action {
    4.  
    5.     // 约束 有人帮我们实现-
    6.     // abstract ,抽象方法，只有方法名字，没有方法的实现。
    7.     //约束- 有人帮我们实现 抽象方法，只有方法的名字，没有方法的实现
    8.     public abstract void doSomething();
    9.  
    10.     //1.不能new这个抽象类， 只能靠子类去实现它，约束。
    11.     //2.抽象类中可以写普通的方法
    12.     //3.抽象方法必须在抽象类中
    13.     //抽象的抽象 ： 约束
    14.  
    15.     // 思考题  new ， 存在构造器吗？
    16.     //存在的意义 抽象出来， 提高开发效率
    17. }
    1. package org.psmaxwell.oop.demo08;
    2.  
    3. //抽象类的所有方法，都继承了它的子类，都必须要实现它的方法 除非
    4. public class A extends Action{
    5.     @java.lang.Override
    6.     public void doSomething() {
    7.  
    8.     }
    9. }

    15.接口的定义与实现

    1. package org.psmaxwell.oop.demo09;
    2.  
    3. //抽象的思维  Java
    4.  
    5.  
    6.  
    7. //interface 定义的关键字, 接口都需要有实现类。
    8. public interface UserService {
    9.  
    10.     //常量
    11.     public static final int AGE = 99;
    12.  
    13.  
    14.  
    15.     //接口中的所有定义其实都是抽象的public
    16.     void run(String name);
    17.     void delete(String name);
    18.     void update(String name);
    19.     void query(String name);
    20. }
    1. package org.psmaxwell.oop.demo09;
    2.  
    3. //抽象类 ： extends
    4. // 类 可以实现接口 implements 接口
    5. // 实现了接口的类， 就需要重写接口中的方法
    6. //利用接口实现多继承
    7. public class UserServiceImpl implements UserService,TimeService{
    8.     @java.lang.Override
    9.     public void run(java.lang.String name) {
    10.  
    11.     }
    12.  
    13.     @java.lang.Override
    14.     public void delete(java.lang.String name) {
    15.  
    16.     }
    17.  
    18.     @java.lang.Override
    19.     public void update(java.lang.String name) {
    20.  
    21.     }
    22.  
    23.     @java.lang.Override
    24.     public void query(java.lang.String name) {
    25.  
    26.     }
    27.  
    28.     @java.lang.Override
    29.     public void timer() {
    30.  
    31.     }
    32. }
    1. package org.psmaxwell.oop.demo09;
    2.  
    3. public interface TimeService {
    4.     void timer();
    5. }

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

    16.N种内部类

    1. package org.psmaxwell.oop.demo10;
    2.  
    3. public class Outer {
    4.  
    5.     private int id=10;
    6.  
    7.     public void out(){
    8.         System.out.println("这是外部类的方法");
    9.     }
    10.  
    11.     public  class Inner{
    12.         public void in(){
    13.             System.out.println("这是内部类的方法");
    14.         }
    15.  
    16.         //获得外部类的私有属性
    17.         public void getID(){
    18.             System.out.println(id);
    19.         }
    20.     }
    21. }
    1. package org.psmaxwell.oop;
    2.  
    3. import org.psmaxwell.oop.demo10.Outer;
    4.  
    5. public class Application {
    6.     public static void main(String[] args) {
    7.  
    8.         // new
    9.         Outer outer = new Outer();
    10.         //通过这个外部类来实例化内部类
    11.         Outer.Inner inner = outer.new Inner();
    12.         inner.in();
    13.         inner.getID();
    14.     }
    15. }
    1. package org.psmaxwell.oop.demo10;
    2.  
    3. public class Outer {
    4.     //局部内部类
    5.     public void method(){
    6.  
    7.         class Inner{
    8.             public void in(){
    9.                 
    10.             }
    11.         }
    12.  
    13.     }
    14.  
    15. }
    16.  
    17. //一个java类中可以有多个class类，但只能有一个public class
    18. //class A{
    19. //    public static void main(String[] args) {
    20. //
    21. //    }
    22. //}
    1. package org.psmaxwell.oop.demo10;
    2.  
    3. public class Outer {
    4.     //局部内部类
    5.     public void method(){
    6.  
    7.         class Inner{
    8.             public void in(){
    9.  
    10.             }
    11.         }
    12.  
    13.     }
    14.  
    15. }
    16.  
    17. //一个java类中可以有多个class类，但只能有一个public class
    18. //class A{
    19. //    public static void main(String[] args) {
    20. //
    21. //    }
    22. //}
    1. package org.psmaxwell.oop.demo10;
    2.  
    3. public class Test {
    4.     public static void main(String[] args) {
    5.         //没有名字初始化类，不用讲实例保存到变量
    6.         new Apple().eat();
    7.  
    8.         UserService userService = new UserService(){
    9.             @java.lang.Override
    10.             public void hello() {
    11.  
    12.             }
    13.         };
    14.  
    15.     }
    16. }
    17.  
    18. class Apple{
    19.     public void eat(){
    20.         System.out.println("1");
    21.     }
    22. }
    23.  
    24. interface UserService{
    25.     void hello();
    26. }
  • 相关阅读:
    C#获取http请求的JSON数据并解析
    2022前端面试题总结
    区块链模块化的破局之路
    android源码学习-android异常处理机制
    【预测模型-SVM预测】基于粒子群算法结合支持向量机SVM实现Covid-19风险预测附matlab代码
    mplfinance 一个堪称完美python量化金融可视化工具详析
    官宣！Sam Altman加入微软，OpenAI临时CEO曝光，回顾董事会‘’政变‘’始末
    web：[SUCTF 2019]EasySQL
    平面运动机器人的传感器外参标定
    springboot项目如何打包成.sh脚本形式运行｜assemly插件打包自定义脚本参数
  • 原文地址：https://blog.csdn.net/u011868279/article/details/126296394