Java面对对象

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

抽象

三大特性

封装
继承
多态

静态类前面有static 可以直接用

非静态类不能直接用需要实例化 new

静态方法和类一起加载非静态方法要类实例化之后才存在

形参和实参

public static void main(String[] args) {
    System.out.println(add(1, 3));//1 3 是实参
}
public static int add(int a,int b){//a b 是形参
    return a+b;
}

对象是具体的事物类是抽象的

动物是类叫旺财的狗是对象真实存在

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

构造器

类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：

必须和类的名字相同
必须没有返回类型，也不能写void

构造器必须要掌握

//属性： 字段
String name;
int age;
//方法
public void sayHello(){
    System.out.println(this.name+"hello");//this关键字 就是指自己
}
//构造器 作用是实例化初始值
//使用new关键字 本质就是在调用构造器
//new完后默认生成了一个无参构造器 只是不显示 默认的都是数据类型默认的初始值
//我们如果写了一个构造器 就把系统默认生成的给覆盖掉
//自己写构造器 和类的名字相同 没有返回类型，也不能写void
//如果写了一个有参构造器 就一定要写一个无参构造器 否则报错
public Student(){
    this.age=22;
}
public Student(String name){
    this.name=name;
}

public static void main(String[] args) {
    Student xiaoming = new Student("小花");
    //xiaoming.name="小明";
    xiaoming.sayHello();

}

封装

要求高内聚，低耦合

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外部使用。

信息隐藏：通常应禁止直接访问一个对象中的实际表示，而应通过操作接口来访问

属性私有

类中的属性就要封装 private 这时哪怕在类中实例对象也无法直接获取其私有属性

想要操作就用get/set来帮助实现

public static void main(String[] args) {
    Student student=new Student();
    System.out.println(student.age);//报错 无法使用age私有属性
    student.say();
    student.setAge(3);
    System.out.println(student.getAge());//3
}

public class Student {
    private int age;
    private String name;
    public void say(){
        System.out.println("hello");
    }
    //get/set

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

继承

extend

类有很多种其中有包含关系如：动物类植物类狗类猫类人类学生类

其中动物类的所有属性人类狗类都有这时动物类就是人类的父类基类人类是动物类的子类或者派生类是人类继承了动物类

public class Student extends Person{

}

public class Person {
    private int age;
    private int id;
    private String name;
    public void say(){
        System.out.println("hello");
    }
}

public static void main(String[] args) {
    Student student =new Student();
    student.say();//hello
}

继承是类和类之间的关系。还有依赖，组合，聚合等关系后面学。

子类和符类可以理解为“is a”的关系

在Java种所有的类都默认继承了object类

Java中只有单继承没有多继承一个父亲有多个儿子一个儿子只有一个爸爸

Super

super和this对比

this是当前类 super是父类

调用属性

父类

public class Person {
    private int age;
    private int id;
    protected String name = "父亲";

    public void say() {
        System.out.println("hello");
    }

}

子类

public class Student extends Person{
    private String name="儿子";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

main类

public static void main(String[] args) {
    Student student =new Student();
    student.test("xiao");
}
//xiao
//儿子
//父亲

调用方法

父类

public void say() {
    System.out.println("hello");
}

子类

public class Student extends Person{
    private String name="儿子";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void say() {
        System.out.println("Student");
    }

    public void test2(){
        say();
        this.say();
        super.say();
    }
}

main类

public static void main(String[] args) {
    Student student =new Student();

    student.test("xiao");
    //xiao
    //儿子
    //父亲
    student.test2();
    //Student
    //Student
    //hello
}

私有属性和方法不能被继承

关于构造器的机制

父类

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

子类

public Student() {
        //隐藏代码：调用了父类的无参构造
        //隐藏了super(); 调用父类的构造器必须是第一行
        System.out.println("Student无参构造器执行了");
}

main类

Student student =new Student();
//
//Person无参构造器执行了
//Student无参构造器执行了
//先父类 后子类

super注意点：

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

vs this:

代表的对象不同：

this：本身调用者这个对象

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

前提

this：没用继承也可以使用

super：只能在继承条件才可以使用

构造方法

this(); 本类的构造

super(); 父类的构造

方法重写

重写都是方法的重写和属性无关

父类

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

子类

public class Dog extends Animal{
    public void test(){
        System.out.println("Dog");
    }
    public static void test2(){
        System.out.println("Dog");
    }
}

main类

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.test();

        //父类的引用指向了子类
        Animal animal = new Dog();//子类重写了父类的方法
        animal.test();
        System.out.println("------------------");
        dog.test2();
        animal.test2();
        //Dog
        //Dog
        //------------------
        //Dog
        //Animal
    }

静态和类一起

非静态可以重写

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

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小： Public>Protected>Default>Private
抛出的异常：范围，可以缩小，但不能扩大：ClassNotFoundException 下标溢出-->Exception(大)

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

为啥需要重写：

父类的功能，子类不一定需要，或者不一定满足！
Alt+Insert：override

多态

动态编译:类型可扩展性

即同一种方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

有继承关系
子类重写父类方法
父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

instanceof 类型转换引用类型的转换

父类

public class Computer {
    public void launch(){
        System.out.println("启动");
    }
}

子类

public class CPU extends Computer{
    public void launch(){
        System.out.println("CPU");
    }
    public void add(){
        System.out.println("加法");
    }
}

main类

public static void main(String[] args) {
    //一个对象的实际类型是确定的
    //new Computer();
    //new CPU();

    //可以指向的引用类型就不确定了
    //CPU 能调用的方法都是自己或继承父类的
    CPU cpu = new CPU();
    //父类的引用指向了子类
    //Computer 父类型，可以指向子类 但不能调用子类独有的方法
    Computer computer =new CPU();
    Object object = new CPU();

    cpu.launch();
    computer.launch();//子类重写了父类的方法 执行子类的方法 结果还是CPU

    //对象能执行那些方法，主要看=左边的类型 和=右边关系不大
    cpu.add();
    //Computer.add();报错
    ((CPU) computer).add();//强制把父类转化为子类 才可以
}

多态的注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系可以强制转换不相关的类强制转换会异常 ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 =new Son();

static 修饰的方法属于类不属于实例

final 修饰的是常量属性不能被重写更不可能多态

private修饰的方法私有不能重写更不能多态

Instanceof

判断一个类是否属于另一个类

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(person instanceof String);//编译错误
}

类型转换

public static void main(String[] args) {
    //类型之间转换 ： 低转高： 自动转 不用管 被动转 高转低： 强制转
    //高                     低
    Person obj = new Student();
    //student.go();报错 student将这个对象转换位Student类型，我们就可以使用Student类型的方法
    Student student = (Student) obj;
    student.go();
    //这两句等价于 ((Student) obj).go();
    //--------------
    System.out.println("------------------");
    Student student1 = new Student();
    student1.go();
    Person person =student1;//自动转
}

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型：强制转换
方便方法的调用，减少重复的代码

Static

//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 person1=new Person();
}
//静态代码块
//匿名代码块
//构造方法
//----------------
//匿名代码块
//构造方法

看输出顺序静态代码是最先执行的其次是匿名代码块然后才是构造方法

但是静态执行一次后就不会再执行它和类是一起的

System.out.println(Math.random());//0.2764692506603377

Math.random();//随机生成一个数

这里调用了一个Math类静态导入包可以不用再在random()方法前加Math

package com.oop;
import static java.lang.Math.random;
public class Demo9 {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

当一个类被修饰符final定义就无法被继承

抽象类

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

别的类继承抽象类会报错 alt+Enter 提示要重写这个类 Implement method

//public class A extends Action{
//}//报错
public class A extends Action{
    @Override
    public void doSomething(){
        
    }
}

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

接口

interface

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范，自己无法写方法，专业的约束！约束和实现分离：面向接口编程

接口就是规范，定义的是一组规则，提现了现实世界中“如果你是...则必须能...”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。
接口本质是锲约，就像我们人间的法律一样。制定好后大家都遵守。
OO（面对对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么讨论设计模式都是只针对具备了抽象能力的语言（比如C++，Java，C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

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

接口都要有实现类命名都以Impl结尾

要实现接口 alt+Enter 重写即可

重写抽象方法不用也是这个快捷键但是不会现实在代码里这里直接会有Implement

public class UserServiceImpl implements UserService,TimerService{}
//这么写会报错 alt+Enter 选择implement method即可重写

接口类

//抽象的思维 是java的重点

public interface UserService {
    //接口中的所有定义都是抽象的 里面的方法都默认 public abstract
    //抽象的方法都要有实现类

    //接口里的常量 前面默认是public static final 不能被引用 一般不会在接口里定义常量
    int age =90;
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
}

public interface TimerService {
    void timer();
}

实现类

//类可以实现接口 implements 接口
//实现了接口的类 就需要重写接口中的方法
//多继承可以利用接口实现
public class UserServiceImpl implements UserService,TimerService{

    @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 abstract final
接口不能被实例化接口中没有构造方法
implements可以实现多个接口
必须要重写接口中的方法

内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类就是内部类，而A类相对B类来说就是外部类

成员内部类
静态内部类
局部内部类
匿名内部类

main类

public static void main(String[] args) {
    Outer outer=new Outer();
    //通过外部类实现内部类
    Outer.Inner inner = outer.new Inner();
    inner.in();//这是内部类的方法
    inner.getID();//10 
}

外部类

public class Outer {

    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

posted @ 2022-09-15 16:56 看我雷霆半月斩阅读(29) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java面对对象

三大特性

构造器

封装

继承

Super

调用属性

调用方法

关于构造器的机制

方法重写

多态

Instanceof

类型转换

Static

抽象类

接口

内部类

公告