Java面向对象-CSDN博客

本文链接：https://blog.csdn.net/Forgetxb/article/details/113689657

面向对象

面向过程 & 面向对象

package com.oop.demo01;

import java.io.IOException;

//Demo01 类
public class Demo01 {

    //main  方法
    public static void main(String[] args) {

    }


    /*
    * 修饰符   返回值类型    方法名（...）{
    *   //方法体
    *   return 返回值；
    * }
    * */
    public String sayHello(){
        return "hello,world!";
    }

    public  void hello(){
        return;
    }

    public int max(int a, int b){
        return a>b ? a : b; //三元运算符！
    }

    //数组元下标越界异常：Arrayindexoutofbounds
    public void readFile(String file) throws IOException{
        //抛出异常
    }
}

package com.oop.demo01;

public class Demo02 {

    public static void main(String[] args) {
        Student.say();

        //实例化这个类
        //对象类型 对象名 = 对象值；
        Student student = new Student();

        student.say1();
    }
}

package com.oop.demo01;

//值传递
public class Demo03 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo03.change(a);
        System.out.println(a);
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

package com.oop.demo01;

//引用传递：对象，本质还是值传递
public class Demo04 {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);//null

        Demo04.change(person);

        System.out.println(person.name);
    }

    public static void change(Person person){
        //person是一个对象：指向的--->Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "香槟";
    }
}

//定义了一个Person类，有一个属性:name；
class  Person{
    String name;
}

package com.oop.demo02;

//
public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器

    String name;
    int age;
//    //实例化初始值
//    //1. 使用new关键字，本质是在调用构造器
//    public Person(){
//        this.name = "xiangbin";
//    }
//
//    //有残构造：一旦定义了有参构造，无参就必须显示定义
//    public Person(String name){
//        this.name = name;
//    }

    //alt+insert:如下


    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * public static void main(String[] args) {
     *
     *         //new 实例化了一个对象
     *         Person person = new Person("xiangbin");
     *
     *         System.out.println(person.name);//xiangbin
     *     }
     *
     *
     *     构造器：
     *     1.和类名相同
     *     2.没有返回值
     *     作用：
     *     1.new本质在调用构造方法
     *     2.初始化对象的值
     *     注意点：
     *     1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
     *
     *     Alt + Insert
     *
     *     this. =
     * */
}

package com.oop.demo02;

//学生类
public class Student {

    //属性：字段
    String name;//null
    int age;// 0


    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

/**
 *   public static void main(String[] args) {
 *         //类：抽象的，实例化
 *         //类实例化后会返回一个自己的对象！
 *         //student对象就是Student类的具体实例！
 *         Student student = new Student();
 *         Student xiaoming = new Student();
 *         Student xiaohong = new Student();
 *
 *         xiaoming.name = "小明";
 *         xiaoming.age = 20;
 *         System.out.println(xiaoming.name);
 *         System.out.println(xiaoming.age);
 *         xiaohong.name = "小红";
 *         xiaohong.age = 20;
 *         System.out.println(xiaohong.name);
 *         System.out.println(xiaohong.age);
 *     }
 *
 *
 *
 * */

package com.oop.demo03;

public class Pet {

    public String name;
    public int age;

    //无参构造

    public void shout(){
        System.out.println("叫了一声");
    }
}


/**
 *  public static void main(String[] args) {
 *
 *         Pet dog = new Pet();
 *
 *         dog.name = "旺财";
 *         dog.age = 3;
 *         dog.shout();
 *
 *         System.out.println(dog.name);
 *         System.out.println(dog.age);
 *
 *         Pet cat = new Pet();
 *     }*/

三大特性

封装
继承
多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

//一个项目应该只存一个main方法
public class Application {

   /*
   1.类与对象
      类是一个模板，抽象，对象是一个具体的实例
   2.方法
   定义、调用
   3.对象的引用
        基本类型：8个
        引用类型：
        对象是通过引用来操作的：栈--->堆

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

        修饰符     属性类型  属性名 = 属性值！
   5.对象的创建和使用
        - 必须使用new  关键字创造对象，构造器  Person xiangbin = new Person();
        - 对象的属性  xiangbin.name
        - 对象的方法  xiangbin.study()

   6.类：
        静态的属性   属性
        动态的方法   方法

        ` 封装、继承、多态 `
    */
}

封装

package com.oop.demo04;

public class Student {


    private String name;   //名字
    private int id;        //学号
    private char sex;      //性别
    private int age;       //年龄


    //提供一些可操作这个属性的方法
    //提供一些public的get、set方法

    //get  获得这个数据
    public String getName(){
        return this.name;
    }

    //set  给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }
}
///*
//1. 提高程序的安全性，保护数据
//2. 隐藏代码的实现细节
//3. 统一接口
//4. 系统可维护增加了
//
//
//*/
//public class Application{
//
//    public static void main(String[] args) {
//        Student s1 = new Student();
//
//        s1.setName("香槟");
//
//        System.out.println(s1.getName());
//
//        s1.setAge(999);//不合法的
//        System.out.println(s1.getAge());
//    }
//
//    //alt + insert
//
//
//}

继承

super注意点：

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

Vs this：

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用
前提：

this：没有继承也可以使用

super：只能在继承条件下才可以使用
构造方法：

this（）：本类的构造

super（）：父类的构造

重写：

需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大：public > protected > Default>priva
抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException – > Exception(大)

重写，子类的方法和父类必须要一致；方法体不同！
为什么要重写：
1. 父类的功能，子类不一定需要，或者不一定满足！

package com.oop.demo05;

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

    //Override 重写
    @Override //注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}
/**
 *
 *     //静态方法和非静态方法区别很大！
 *         //静态方法：//方法的调用只和左边，定义的数据类型有关
 *
 *     //非静态：重写
 *     public static void main(String[] args) {
 *
 *         A a = new A();
 *         a.test();//A类
 *
 *         //父类的引用指向了子类
 *         B b = new A();//子类重写了父类的方法
 *         b.test();//B类
 *         }*/

package com.oop.demo05;

//学生  is  人： 派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    //Ctrl + H

    private String name = "Dasu";

//    public void test(String name){
//        System.out.println(name);
//        System.out.println(this.name);
//        System.out.println(super.name);
//    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
       print();//Student
       this.print();//Student
       super.print();//Person
    }
}
/*
*    public static void main(String[] args) {

          Student student = new Student();
//        student.say();
//        System.out.println(student.money);

       // student.test("香槟");
        student.test1();
    }
* */

package com.oop.demo05;

//重写都是方法的重写，与属性无关
public class B {

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

package com.oop.demo05;

//父类
//在Java中，所有的类，都默认直接或者间接继承Object
public class Person {

//    public int money = 10_0000_0000;
//
//    public void say(){
//        System.out.println("说了一句话");
//    }
//
//    protected String name = "Xiangbin";


    public Person() {
        System.out.println("Person无参执行了");
    }

    //私有的东西无法被继承！
    public void print(){
        System.out.println("Person");
    }
}

public static void main(String[] args) {

        //一个对象的实际类型是确定的；
        //new Student();
        //new Person();

        //可以指向的引用类型不确定:父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
        s1.eat();
    }

/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系  类型转换异常！ClassCastException!
3.存在条件： 继承关系， 方法需要重写， 父类引用指向子类对象！ father f1 = new Son();

        1.static 方法，属于类，它不属于实例
        2.final 常量；
        3.private方法；
**/

package com.oop.demo06;

public class Student extends Person{

//    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
    public void go(){
        System.out.println("go");  
    }
}
/*
    public static void main(String[] args) {

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=======================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译报错
        System.out.println("=======================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错

    }**/

    public static void main(String[] args) {
        //类型之间的转换： 父  子

        //高                     低
        //Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！

        //Student student = (Student)obj;
        //student.go();
        //((Student)obj).go();

        //子类转换为父类，可能丢失自己本来的一些方法！
        Student student = new Student();
        student.go();
        Person person = student;

    }

/*
1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型；
3. 把父类转换为子类，向下转型； 强制转换
4. 方便方法的调用，减少重复的代码！ 简洁
* **/

static

package com.oop.demo07;

//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(s1.age);
//        System.out.println(s1.score);

    }

}

package com.oop.demo07;

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();
        System.out.println("=========================");
        Person person2 = new Person();
    }
}

package com.oop.demo07;

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

public class Test {

    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

接口

作用：

约束
定义一些方法，让不同的人实现~ 10 —> 1
public abstract
public static final
接口不能被实例化_{，接口中没有构造方法}
implements可以实现多个接口
必须要重写接口中的方法~

package com.oop.demo09;

//抽象的思维~ Java  架构师

//interface 定义的关键字
public interface UserService {

    //常量~ public static final
    int AGE = 99;

    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void updata(String name);
    void query(String name);
}

package com.oop.demo09;

// 抽象类：extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法~
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

package com.oop.demo09;

public interface TimeService {
    void timer();
}

抽象类

package com.oop.demo08;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

package com.oop.demo08;

//abstract 抽象类：类 extends: 单继承~  （接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现~
    //abstract, 抽象方法，指向方法名字，没有方法的实现!
    public abstract void doSomething();

    //1. 不能new这个抽象类，只能靠子类去实现它：约束！
    //2. 抽象类中可以写普通的方法~
    //3. 抽象方法必须在抽象类中~
    //抽象的抽象：约束~

    //思考题？ new，存在构造器么？
        //存在的意义      抽象出来~  提高开发效率
}

内部类

package com.oop.demo10;

import com.oop.demo09.UserService;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中~
        new Apple().eat();

//        UserService userService = new UserService(){
//
//            @Override
//            public void hello() {
//
//            }
//        };
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

//interface UserService{
//    void hello();
//}

package com.oop;

import com.oop.demo10.Outer;

import java.util.Scanner;

public class Application{

    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}