面向对象

本质：以类的方式组织代码，以对象的组织（封装）数据

类与对象的创建

public class Student {
    //属性：字段
    String name;
    int age;

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

import com.opp.demo02.Student

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

构造器

public class Person {

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

    public String name;
    public int age;

    //alt+insert

    //实例化初始值
    //1.使用new关键字，本质是在调用构造器

    public Person() {
    }


    //有参构造：一旦定义了有参构造，无参就必须显示定义

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

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

import com.oop.demo02.Person;

public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("xinyu", 23);
        System.out.println(person.name);//xinyu
    }

构造器：

和类名相同
没有返回值

作用：

new 本质在调用构造方法
初始化对象的值

注意点：

定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

Alt + Insert

this. =

类与对象

类是一个模板；抽象，对象是一个具体的实例
方法

定义、调用
对应的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈 ---> 堆
属性：字段 Field 成员变量

默认初始化：
- 数字：0 0.0
- char：u0000
- boolean：false
- 引用：null
对象的创建和使用
- 必须使用 new 关键字创造对象，构造器 Person yao = new Person();
- 对象的属性 yao.name
- 对象的方法 yao.sleep()
类

静态的属性属性

动态的行为方法

封装

属性私有，get/set

package com.oop.demo04;

//类 private：私有
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;
    }

    //alt + insert

    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;
        }
    }
}

package com.oop;

import com.oop.demo04.Student;

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());
    }
}

提高程序的安全性，保护数据

隐藏代码的实现细节

统一接口

系统可维护性提高

继承

package com.oop.demo05;

//在 Java 中，所有的类，都默认直接或间接继承Object类
public class Person {
    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话")
    }
    public int getMoney(){
        return money;
    }
    public void setMoney(int money){
        this.money = money;
    }
}

package com.oop.demo05;

//派生类，子类
public class Student extends Person{
    //Ctrl + H
}

import com.oop.demo05.Student;
public class Application{
    public static void main(String[] args){
    Student student = new Student();
    student.say();
    System.out.println(student.money);
    }
}

Java类只有单继承，没有多继承

继承

public class Person {
    public Person(){
        System.out.println("Person无参执行了");
    }
    
    protected String name = "Yao";
    //私有的东西无法被继承
    public void print(){
        System.out.println("Person");
    }
}

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

import com.oop.demo05.Student;
public class Application{
    public static void main(String[] args){
        Student student = new Student();
        //student.test("姚欣堉");
        //student.test1();
    }
}

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

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

重写

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

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

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

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

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

多态

package com.oop.demo6;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

package com.oop.demo6;

public class Student extends Person{
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

public static void main(String[] args) {
    //一个对象的实际类型是确定的
    //new Student();
    //new Person();
    
    //可以指向的引用类型不确定：父类的引用指向子类
    
    //Student 能调用的方法都是自己的或者继承父类的
    Student s1 = new Student();
    //Person 父类，可以指向子类，但是不能调用子类独有的方法
    Person s2 = new Student();
    Object s3 = new Student();
    
    //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
    ((Student) s2).eat();//子类重写了父类的方法，执行子类的方法
    s1.run();
}

多态注意事项

多态是方法的多态，属性没有多态

父类和子类，有联系类型转换异常！ClassCastException

存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son();

static 方法，属于类，它不属于实例

final 常量

private 方法

instanceof

public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}

public class Teacher extends Person{
}

public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        Object object = new Student();

        //System.out.println(x instanceof y);//能不能编译通过

        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);//编译报错
        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);//编译报错
    //子类转换为父类，可能丢失自己本来的一些方法
    Student.student = new Student();
    student.go();
    Person person = student;

    }

父类引用指向子类的对象

把子类转换为父类，向上转型

把父类转换为子类，向下转型，强制转换

方便方法的调用，减少重复的代码

static

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

//静态导入包
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);
    }
}

抽象类

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

    //约束 有人帮助实现
    //abstract，抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

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

}

public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

//抽象的思维
//interface 定义的关键字      接口都需要有实现类
public interface UserService {
    //接口中的所有定义都是抽象的 public abstract

    //常量 public static final
    int AGE = 99;
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}

//抽象类：extends
//类 可以实现接口 implements 接口
//实现了接口中的类，需要重写接口中的方法

//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

作用：

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

内部类

public class Outer {
    public void method(){
        class Inner{
            public void in(){

            }

        }
    }

}

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

            }
        };

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

}
interface UserService{
    void hello();
}

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

posted @ 2022-09-26 21:05 YlMXY 阅读(47) 评论(0) 收藏举报

刷新页面返回顶部

YlMXY

面向对象

面向对象

类与对象的创建

构造器

封装

继承

继承

重写

多态

instanceof

static

抽象类

接口

内部类

公告