初识面向对象（Java核心思想）

class Person {
    String name;
    int age;
    //被封装的属性
    private double money = 100;

     public double getMoney(){
        return money;
    }
}

（2）继承：子承父业，子类会获得父类（也称超类）的所有非私有方法和属性

使用关键字extends，代表该类是谁的子类（子类是父类的拓展）

在Java中，所有的类都直接或间接继承object类

注意：Java类中只有单继承！

快速查看继承树：ctrl + h

public class Application {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name);
        System.out.println(son.money);
        son.AAA();
    }
}

public class Son extends Father {
    
}
 
public class Father {
    public String name = "w";
    double money = 1000000;
    public void AAA(){
        System.out.println("father的方法");
    }
}

（3）多态（高拓展性）：同一件事不同结果

前提知识：方法重写（非静态/非私有方法）

        //一个对象的实例类型是可以确定的，但其指向的引用类型就不确定了
        //如父类的引用指向子类
        //能调用的方法都是自己拥有或从父类继承的
        Son son1 = new Son();
        //父类型，但是不能调用子类独有的方法
        Father son2 = new Son();
        Object son3 = new Son();

        //对象能执行哪些方法，主要看左边的类型！ 
        son1.b();
        //一旦子类重写了父类的方法，就会执行子类的方法
        son2.b();
        son2.c();

public class Father {
    public String name = "w";
    double money = 1000000;

    public void aaa(){
        System.out.println("father的方法");
    }

    public void b(){
        System.out.println("father-b");
    }
    public void c(){
        System.out.println("father-c");
    }
}
public class Son extends Father {

    @Override（注解后面说）
    public void b(){
        System.out.println("son-b");
    }

    public void d(){
        System.out.println("son-d");
    }
}

多态注意点：

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

条件：

①子类重写了父类方法

②父类引用指向子类对象

判断引用类型间的关系：instanceof

使用方法：

A instanceof B ==》判断A和B是否有关系

7、静态方法与非静态方法

（1）静态方法：static修饰的方法，属于类

写一个Student类

public class Student {

    public static void study(){
        System.out.println("学生方法");
    }
}

再写一个People类，入口写在该类中，调用Student类的study方法

public class People {
    public static void main(String[] args) {
        Student.study();
    }
}

（2）非静态方法

Student类再写一个非静态方法

public class Student {

    public void study1(){
        System.out.println("学生方法");
    }
}

People调用方法，需要实例化

public class People {
    public static void main(String[] args) {
        //静态调用
        Student.study();

        //非静态调用,需要
        //new Student.study1();
        Student student = new Student();
        student.study1();
    }

}

（3）两者区别

（1）修饰不同：静态需要static修饰，而非静态则不需要。

（2）时机不同：静态方法在类定义的时候已经被装载和分配，而非静态方法在类定义时并没有创建和加载，只有在类被实例化为对象时，才会装载和分配。这也是为何在静态方法中直接调用非静态方法会报错。

8、引用传递（本质还是值传递）

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

        Person person = new Person();
        System.out.println(person.name);
        
        change(person);
        System.out.println(person.name);

    }

    public static void change(Person person){
        person.name = "XXX";
    }
}
class Person {
    String name;
}

9.类与对象

类：类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，并不能代表某一个具体的事物

如动物、植物

对象：对象是抽象概念的具体实例

如：张三，张三的狗旺财

10.类的声明

类的组成：属性+方法

类的声明：修饰符 + class + 类名{}

类实例化会返回一个对象（具体个体）。

class Person {
    //属性
    String name;
    int age;
    //方法
    public void walk(){}
    public void look(){}
}

11.对象的创建与初始化

使用new关键字创建，本质是在调用构造器

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

构造器：类中的构造器也称构造方法，是在进行创建对象时必须要调用的。

构造器：IDEA快捷键 alt + ins

（1）与类名相同

（2）没有返回类型，不能写void

（3）一个类就算什么也不写，也会存在一个构造方法

作用

（1）实例化初始值

Person person = new Person();
System.out.println(person.name);
//注意，使用有参构造后必须显示定义无参构造（写出无参构造）
Person person1 = new Person("张三");
System.out.println(person1.name);

class Person {
    String name;
    int age;
    //无参构造方法
    public Person(){
        System.out.println("无参构造");
    }
    //有参构造方法
    public Person(String name){
        System.out.println("有参构造");
        this.name = name;
    }
    
    public void walk(){}
    public void look(){}
}

12.this和super的区别

public class Computer {
    protected String name = "电脑";
    
    public Computer(){
        System.out.println("父类构造执行");
    }

     public void print(){
        System.out.println("输出Computer");
    }
}

public class Lenovo extends Computer{
    private String name = "联想";
    
     public Lenovo(){
        //子类构造会默认执行super();
        //super();默认是隐藏在第一行，调用父类构造器必须在第一行
        System.out.println("子类构造执行");
    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

     public void test1(){
        print();
        this.print();
        super.print();
    }
    @Override
    public void print(){
        System.out.println("输出联想");
    }
}

public class Application {
    public static void main(String[] args) {
        Lenovo computer = new Lenovo();
        computer.test("苹果");
        lenovo.test1();
    }
}

（1）super注意点

①super调用父类的构造方法，必须在构造方法的第一行

②super只能出现在子类的方法或构造方法中

③super和this不能同时调用构造方法

（2）this和super的区别

①对象不同：

this：调用者这个对象

super：代表父类对象的应用

②使用条件

this：没继承也可使用

super：只能在继承条件下使用

③构造方法

this：本类的构造

super：父类的构造

13.重写（需要有继承关系！）

重写的必要性：

父类的功能子类不一定需要/满足

重写：

（1）方法名必须相同

（2）参数列表必须相同

（3）修饰符范围：可以扩大但不能缩小（public > protect > default >private）

（4）抛出的异常范围：可以缩小但不能扩大（Exception > 其他异常）

IDEA快捷键alt + ins -> override

14.向上转型和向下转型

向上：子类转父类

向下：父类转子类（需要强转，可能会丢失方法）

15.static

package oop.staticdemo;
//静态导包
import static java.lang.Math.random;
/**
 * @author LEGION
 */
public class StaticDemo {
    private int num01;
    private static int num02;
    //代码块（匿名）
    {
        System.out.println("匿名代码块");
    }
    //静态代码块，只执行一次
    static {
        System.out.println("静态代码块");
    }

    public void A01(){

    }
    public static void A02(){

    }

    public static void main(String[] args) {

        StaticDemo staticDemo = new StaticDemo();
        int num01 = staticDemo.num01;
        int num02 = StaticDemo.num02;

        staticDemo.A01();
        StaticDemo.A02();
        A02();
        //可以直接random()
        System.out.println(random());

    }
}

16.抽象类

被abstract修饰的类

特点：

①不能new出来，只能靠子类去实现它，主要作用是约束

②抽象类中可以写普通方法

③抽象方法必须在抽象类中

抽象类存在构造器！

/**
 * @author LEGION
 * abstract修饰的类-抽象类
 */
abstract public class AbstractDemo01 {
    /**
     * abstract修饰的方法-抽象方法，没有方法的实现
     *需要子类实现
     */
    abstract public void doSomething();
}

/**
 * @author LEGION
 * 抽象类的所有方法，继承了它的子类都必须实现它的方法
 */
public class Realize extends AbstractDemo01{

    @Override
    public void doSomething() {

    }
}

抽象类作用：提高开发效率

17.接口（本质是契约）

接口就是规范，专业约束----做到约束与实现的分离

//接口都需要实现类
public interface UserService {
     //接口中所有定义都是public abstract
    void add();
}

public interface TimeService {
      /**
     * 接口定义的属性为常量
     * public static final long START = 0;
     */
    long START = 0;
    /**
     * 计时
     */
    void time();
}

接口的实现：implement关键字

实现接口的类必须实现接口的方法,一个类可以实现多个接口（多实现）

public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add() {

    }

    @Override
    public void time() {

    }
}

注意：

接口不能实例化，没有构造方法

18.内部类

（1）成员内部类

public class Demo01 {
    private int id = 1;
    public void out(){
        System.out.println("外部类方法");
    }
    class Inner{
        public void inner(){
            System.out.println("内部类方法");
        }

        //获得外部类的私有属性
        public int getID(){
            return id;
        }
    }
}

public class Application {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.out();

        Demo01.Inner inner = demo01.new Inner();
        inner.inner();
        System.out.println(inner.getID());
    }
}

（2）静态内部类

public class Demo01 {
    private int id = 1;
    public void out(){
        System.out.println("外部类方法");
    }
    class static Inner{
        public void inner(){
            System.out.println("内部类方法");
        }

        //获得外部类的私有属性
        public int getID(){
            return id;
        }
    }
}

（3）局部内部类

public class Demo01 {
    private int id = 1;
    public void out(){
        System.out.println("外部类方法");
        //局部内部类
        class Inner{
        public void inner(){
            System.out.println("内部类方法");
        }

        //获得外部类的私有属性
        public int getID(){
            return id;
        }
    }
    }
   
}

（4）匿名内部类

 //匿名内部类，不用将实例保存在变量中
new Demo01().out();
new Demo01(){
    @Override
    public void out(){

    }
};

辉图

关注

21
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
初识面向对象（Java核心思想）

（2）时机不同：静态方法在类定义的时候已经被装载和分配，而非静态方法在类定义时并没有创建和加载，只有在类被实例化为对象时，才会装载和分配。将问题分类，思考问题首先想解决问题需要哪些分类，再根据这些分类进行单独思考，最后在某个分类的细节进行面向过程的处理。使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中。类：类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，并不能代表某一个具体的事物。构造器：类中的构造器也称构造方法，是在进行创建对象时必须要调用的。
复制链接

扫一扫