java面向对象基础

java面向对象

面向对象编程（OOP）的本质：以类的方式组织代码，以对象的方式组织（封装）数据。

对象是具体的事物；类是抽象的，类是对象的模板。

方法的调用

带修饰符static的方法跟类一起加载，否则实例化后方法才存在。

this关键字的使用。

对象的创建分析

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

构造器

特点

与类的名字一样
没有返回值

注意点

使用new关键字，本质是在调用构造器
一旦定义了有参构造，无参构造就必须显式定义
用来初始化对象属性

对象内存分析

面向对象三大特性

封装

属性私有，get、set

提高程序的安全性，保护数据
隐藏实现细节
统一接口
系统可维护性增加

继承

java只有单继承，没有多继承！

子类（派生类）继承父类（基类），使用关键字extends。

继承是类和类之间的一种关系。

私有的东西无法被继承。

Object

super

子类调用父类的构造器必须放首行（默认调用父类无参构造）。 super()父类的构造 this() 子类的构造
super只能出现在子类的方法或构造器中
super和this不能同时调用构造方法

方法重写

重写是方法的重写，与属性无关。

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

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

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        B b = new A();  //父类的引用指向了子类
        b.test();
    }
}

运行结果：

A=>test()
B=>test()

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

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

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        B b = new A();  //父类的引用指向了子类
        b.test();
    }
}

运行结果：

A=>test()
A=>test()

结论: 静态的方法和非静态的方法区别很大

静态方法：方法的调用只和左边定义的类型有关
非静态方法：重写

注意点：

方法名相同
参数列表相同
修饰符：范围可以扩大，但不能缩小 public>protected>default>private
抛出的异常：范围可以被缩小，但不能扩大

多态

属性没有多态。

一个对象的实际类型是确定的，可以指向的引用类型不确定。

对象能执行哪行方法，主要看左边的引用类型。

存在条件：继承关系、方法重写、父类引用指向子类对象。

无法重写的方法： static final private

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

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) {
    //Student 能调用的方法都是自己的或者继承父类的
    Student s1 = new Student();
    //Person 父类引用指向子类，但不能调用子类独有的方法
    Person s2 = new Student();
    Object s3 = new Student();
    //对象能执行哪些方法，主要看对象左边的类型
    s2.run();   //输出son
    s1.run();   //输出son
    s1.eat();   //输出eat    没有s2.eat()
}

instanceof

存在继承关系才能通过编译。

编译看左，运行看右

true/false 看引用变量指向的对象的实际类型

static

修饰属性、方法，则属性、方法随类一起加载
静态代码块

public class Person {
    //2.赋初值
    {
        System.out.println("匿名代码块");
    }
    //1.只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3.
    public Person(){
        System.out.println("Person()");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("**************************");
        Person person2 = new Person();
    }
}

运行结果：

静态代码块
匿名代码块
Person()

匿名代码块
Person()

静态导入包

import static java.lang.Math.random;

/**
 * @Description
 * @Author: 
 * @Date: 2021/1/22 16:40
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

接口和抽象类

抽象类

//抽象类
public abstract class Action {
    //抽象方法
    public abstract void doSomething();

    //1.不能new抽象类，只能靠子类去继承它
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
}

问：抽象类有构造器吗？存在的意义？提高开发效率

有构造器

接口

接口只有规范，没有实现，约束和实现分离。

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

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 class Outer {
    private int id = 10;
    private void out(){
        System.out.println("这是外部类的方法");
    }

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

        //获取外部类的私有属性 私有方法
        public void getID(){
            System.out.println(id);
            out();
        }
    }
}

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

静态内部类

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

    //访问不到外部类非静态的属性和方法
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }

局部内部类

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

匿名内部类

不用将实例保存到变量中

public class Outer {
    public static void main(String[] args) {
        new Apple().eat();

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

//一个java文件中可以有多个类，但是只能有一个是public修饰
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

posted @ 2021-01-23 10:21 YuefanZZZ 阅读(57) 评论(0) 收藏举报

刷新页面返回顶部

YuefanZZZ

java面向对象基础

java面向对象

方法的调用

对象的创建分析

构造器

面向对象三大特性

封装

继承

Object

super

方法重写

多态

instanceof

static

接口和抽象类

抽象类

接口

内部类

公告