Java学习笔记-面向对象

面向对象部分

Java的核心思想就是OOP
- 面向过程思想：步骤清晰简单，面向过程适合处理一些较为简单的问题。
- 面向对象思想：分类的思维模式，面向对象适合处理一些复杂的问题，适合处理需要多人协作的问题。

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

面向对象编程（Object-Oriented Programming ， OOP）
面向对象的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据。
抽象
三大特性：封装、继承、多态。
从认识论的角度考虑是先有对象后有类。
从代码运行的角度是先有类后有对象。

Java面向对象02：回顾方法的定义和调用

方法的定义：
- 修饰符
- 返回类型
- break和return的区别
- 方法名
- 参数列表
- 异常抛出
方法的调用：
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

静态与非静态，代码如下：

package com.oop;

public class Demo01 {
    //Main 方法
    public static void main(String[] args) {
//        Student.say();
        Student student = new Student();
        student.say();
    }
    //和类一起加载的
    public static void a(){
        b();
    }
    //类实例化之后才存在
    public void b(){
        a();
    }
}

package com.oop;

public class Student {
//    public static void say(){
//        System.out.println("学生说话了");
//    }
    public void say(){
        System.out.println("学生说话了");
    }

}

实参和形参，代码如下：

package com.oop;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数的名字要一一对应
        System.out.println(add(1, 2));
    }
    public static int add(int a,int b){
        return a + b;
    }
}

Untitled

值传递，代码如下：

package com.oop;

//值传递
//以下的两种change方法都是值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
        
        Demo04.change01(a);
//        Demo04.change02(a);

        System.out.println(a);
    }

//    private static void change02(int a) {
//        a = 10;
//        return a;
//    }

    private static int change01(int a) {
        a = 10;
        return a;
    }

}

Untitled

引用传递（和值传递），代码如下：

package com.oop;

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        Demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){//因为是引用类型，都是对同一个内存地址的内容进行修改，所以本质还是值传递
        person.name = "maynerd";
    }
}
//定义了一个Person类，有一个属性：name
class Person{
    String name;
}

Untitled

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

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

使用new关键字创建对象

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

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

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

构造器必须掌握。

tip：好习惯：不要在每一个类里面加上main方法，这样是不好的，因为类里面不应该有main方法，他就是一个单纯的类，而一个程序只有一个主启动类，所以我们可以定义一个大的主启动类或者测试类。所以我们建造一个Application类。

代码如下：

package com.oop.Demo02;

//一个类应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;
        //默认初始化
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        xiaohong.name = "小红";
        xiaohong.age = 3;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);

    }
}

package com.oop.Demo02;

//学生类
public class Student {
    //属性：字段
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name + "在学习");
    }
}

Java面向对象05：构造器详解

查看一下class文件，为什么类里边是空的也能new？

IDEA看class文件步骤：点开项目结构——>点开modules——>把out文件加入进来——>点击OK再Apply。

Untitled

一个类即使什么都不写，它也会存在一个方法。

Untitled

可以显式的定义构造器。

tip：一旦定义有参构造,无参构造就必须显式定义
alt+insert生成构造器，生成有参/无参构造器

Untitled

new对象的过程和有参无参构造，代码如下：

package com.oop.Demo02;

public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    //显式的定义一个构造器
    String name;
    int age;

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

    //快捷键构造alt+insert
    public Person(int age) {
        this.age = age;
    }
}

package com.oop.Demo02;

//一个类应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //new实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);//meynerd
    }
}

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

创建对象代码：

package com.oop.Demo03;

public class Pet {
    public String name;
    public int age;
    public void shout(){
        System.out.println("叫了一声");
    }
}

package com.oop.Demo03;

public class Application {
    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();

    }
}

分析图：

https://www.notion.so/791a81450ab644faa4bbe924a0db566e#18c4b8d8670c48e98213219e8a1c47f7

参考数组部分：三种初始化及内存分析

Untitled

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

Java面向对象08：封装详解

高内聚，低耦合：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量方法给外部使用。

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

tip：

属性私有，get/set。
alt+insert快捷键生成get/set方法
封装：
- 提高程序的安全性，保护数据
- 隐藏代码实现细节
- 统一接口
- 系统可维护性增加

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 name;
    }
    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    //alt+insert快捷键生成get/set方法

    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) {
            System.out.println("年龄不合法!已自动设定为3岁！");
            this.age = 3;
        }
        else this.age = age;
    }
}

package com.oop.Demo04;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码实现细节
    3.统一接口
    4.系统可维护性增加
 */

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("maynerd");
        System.out.println(s1.getName());
        s1.setAge(130);//不合法数据
        s1.setAge(-1);//不合法数据
        System.out.println(s1.getAge());
    }
}

Java面向对象09：什么是继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
Java类中只有单继承没有多继承！
继承是类和类之间的一种关系。除此以外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类）一个为父类（基类）。子类继承父类，使用关键字extends来表示。
- Object类
- super-this
- 方法重写

tip：ctrl+H打开继承树。

Java中所有的类都默认直接或者间接继承Object类。

Object类，代码如下：

package com.oop.Demo05;

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

//        Person person = new Person();
//        person.
    }
}

package com.oop.Demo05;

/*
    基类
 */
public class Person /* extends Object */ {
    public int money = 100000;
//    private int money = 100000;//私有的是无法继承的

    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{

}

package com.oop.Demo05;

/*
    派生类
 */
public class Teacher extends Person{

}

继承树，如图：

Untitled

Java面向对象10：super详解

父类子类属性的关系测试，代码如下：

Untitled

父类子类方法测试，代码如下：

Untitled

父类子类构造器测试，代码如下：

Untitled

tip：

super注意点：
1. super调用父类的构造方法，必须在构造方法的第一个。
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不嫩恶搞同时调用构造方法！
super 跟this 的区别：
- 代表对象不同：
  
  this：本身调用者这个对象
  
  super：代表父类对象的引用
- 前提：
  
  this：没有继承也可以使用
  
  super：只能在继承条件下才可以使用
- 构造方法：
  
  this（）：本类的构造
  
  super（）：父类的构造

代码如下：

package com.oop.Demo05;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("lm");
        System.out.println("==============");
        student.test02();
    }
}

package com.oop.Demo05;

/*
    派生类
 */
public class Student extends Person02{

    //构造器测试
    public Student() {
        //隐藏代码：先调用了父类的无参构造
        //super();//且必须放在下面语句的上面，不可调换位置
        System.out.println("Student（子类）无参构造器执行了！");
    }

    //属性测试
    private String name = "lianming";
    public void test(String name){
        System.out.println(name);//传进来的lm
        System.out.println(this.name);//本类的lianming
        System.out.println(super.name);//父类的maynerd
    }

    //方法测试
    public void test02(){
        print();//Student
        this.print();//Student
        super.print();//Person02
    }
    public void print(){
        System.out.println("Student");
    }

}

package com.oop.Demo05;

/*
    基类
 */
public class Person02 /* extends Object */ {

    //构造器测试
    public Person02() {
        System.out.println("Person（父类）无参构造器执行了！");
    }

    //属性测试
    protected String name = "maynerd";

    //方法测试
    //私有的方法或者变量无法被继承
    public void print(){
        System.out.println("Person");
    }
}

Java面向对象11：方法重写

Untitled

package com.oop.Demo055;

public class Application {
    public static void main(String[] args) {

        A a = new A();
        a.test();//A

        //父类的引用指向子类
        //方法调用只和左边，定义的数据类型有关
        B b = new A();
        b.test();//B
    }
}

package com.oop.Demo055;

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

package com.oop.Demo055;

//重写都是方法的重写，和属性无关
public class B {
    public static void test(){
        System.out.println("B的test()");
    }
}

把关键字static删掉会出现如图标记吗，表明方法重写：

Untitled

把A中的方法test删了，alt+insert重写该方法：

Untitled

再点击执行，可以发现，都是B的test。可见静态方法和非静态方法的区别：

Untitled

tip：

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

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

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

为什么要重写？父类的功能，子类不一定需要或者不一定满足。

Java面向对象12：什么是多态

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

虽然new的是Student，但是用的是父类的方法，因为子类继承父类。

Untitled

子类重写一下父类方法，输出，可以发现，子类对象s1照常输出自己方法，输出son，父类s2因为方法重写也输出son。

Untitled

子类增加eat，发现父类无法使用，只能强制转换后可以使用。

Untitled

package com.oop.Demo06;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Strdent();
        //mew Person();

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

        s2.run();//子类重写了父类方法，执行子类方法
        s1.run();

        ((Student)s2).eat();//只能强制类型转换才能执行
    }
}

package com.oop.Demo06;

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

package com.oop.Demo06;

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

多态注意事项：

多态是方法的多态，属性没有多态。
父类和子类，有继承关系，才能进行强制类型转换。类型转换异常ClassCastException！
存在条件：继承关系，方法需要重写，父类引用指向子类对象。Father f1 = new Son();
哪些方法不能重写？
1. static 方法，属于类，它不属于实例
2. final常量
3. private方法

Java面向对象13：instaceof和类型转换

A instanceof B用来判断A是否与B（或者B的左边定义的引用数据类型）有直接或者间接的继承关系。

总结：有关系的才能编译通过，毫无关系的，不能编译通过。有父子关系的是true，没有父子关系的是false

代码如下：

package com.oop.Demo06;

public class Application02 {
    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);//true
        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);//false
        System.out.println("==================================================");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
//        System.out.println(student instanceof Teacher);
//        System.out.println(student instanceof String);
    }
}

Untitled

强制类型转换实例：

向下转：强制转换，可以使用子类方法，和父类方法。

package com.oop.Demo06;

public class Application03 {
    public static void main(String[] args) {
        //类型之间的转换：高转低
        //高              低
        Person obj = new Student();
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        ((Student)obj).go();//子类方法
				((Student)obj).run()//父类方法
    }
}

Untitled

向上转：会丢失一些子类自己的一些方法。

package com.oop.Demo06;

public class Application03 {
    public static void main(String[] args) {
        //类型之间的转换：高转低
        Student student = new Student();
        student.go();
        Person person = student;
        //子类转换为父类，可能丢失自己本来的一些方法！
//        person.go();
    }
}

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

tip：static修饰的变量和方法是随类一起加载的。调用非静态方法只能new一个对象，通过对象调用该方法。非静态方法可以访问类中的静态方法。静态方法也可以调用类中静态方法，但不能调用非静态方法。

new对象时，关于static的一些执行顺序：

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

Untitled

关于静态导入包：

package com.oop.Demo07;

//静态导入包:就可以直接使用Math中的方法，不需要加Math前缀
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);
    }
}

Untitled

tip：另外，被final修饰的类无法被继承！

Java面向对象15：抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

package com.oop.Demo08;

//抽象类
public abstract class Action {
    //约束，有人帮我们实现
    //abstract，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

}

package com.oop.Demo08;

public class ActionSon extends Action {

    @Override
    public void doSomething() {

    }
}

tip：

抽象类中可以没有抽象的方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的，
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
Java的类为单继承，接口可以多继承。

特点：

抽象类不能new出来，只能靠子类去实现它：他就是一个约束！
抽象类中可以写普通方法。
一旦有抽象方法，必须声明为抽象类。抽象方法必须在抽象类中！
抽象的抽象。

思考题：不能new，那存在构造器吗？存在的意义是什么？（提高开发效率

答：

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

普通类：只有具体实现。

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

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

tip：接口不能被实例化，接口中没有构造方法。

作用：

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

package com.oop.Demo09;

//interface 定义的关键字，将class替换掉了
public interface UserService {
    //接口中的所有定义的变量 都是全局静态常量
    /*public static final */int AGE = 99;

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

    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.oop.Demo09;

public interface TimeService {
    void timer();
}

package com.oop.Demo09;

//抽象类：通过extends
//类可以实现接口 implements 接口
//实现了接口的类就需要重写接口中的方法！
public class UserServiceImp 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() {

    }
}

Java面向对象17：N种内部类

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

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

package com.oop.Demo10;

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

    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
    }
}

package com.oop.Demo10;

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

        inner.getId();
    }
}

Untitled

如果Inner加上public static，那么就成为静态内部类，静态内部类无法访问非静态属性id。

tip：一个.java文件里面可以有多个类，但是只能有一个public的类，测试类就可以直接写在下面。
对象的局部内部类：

package com.oop.Demo10;

public class Outer02 {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

匿名内部类

package com.oop.Demo10;

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

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

接口的匿名内部类

posted @ 2022-02-27 16:08 Maynerd 阅读(43) 评论(0) 编辑收藏举报

刷新页面返回顶部

Maynerd

——有梦的人就该被值得。

Java学习笔记-面向对象

面向对象部分

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

Java面向对象02：回顾方法的定义和调用

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

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

Java面向对象05：构造器详解

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

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

Java面向对象08：封装详解

Java面向对象09：什么是继承

Java面向对象10：super详解

Java面向对象11：方法重写

Java面向对象12：什么是多态

Java面向对象13：instaceof和类型转换

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

Java面向对象15：抽象类

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

Java面向对象17：N种内部类

公告