Java06 面向对象

一什么是面向对象

面向对象编程（Object-Oriented Programming,OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象组织（封装）数据。

三大特性：

封装
继承
多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板。

二，回顾方法

1，方法的定义：

修饰符
返回类型
break和return的区别。（break跳出循环switch；return结束方法，返回结果）
方法名：驼峰命名法
参数列表：（参数类型参数名）
异常抛出

修饰符 返回值类型  方法名（...）{
  方法体
  return 返回值；
}

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

    }
    public String sayHello(){
        return "Hello,World!";   // 返回值必须和定义的类型一致string
    }
    public int max(int a,int b){
        return a>b?a:b;   // 三元运算符
    }
    public void print(){
        return; // 返回值为空
    }
}

2，方法的调用：

静态方法和非静态方法

package oop;

public class demo02 {
    public static void main(String[] args) {
        Student.say();  // 静态方法直接调用
        //非静态方法的调用
        Student stu = new Student();    // 非静态方法需要先进行实例化类
        stu.sayHello(); // 调用
    }
}
----------------------------------------------
package oop;
// 学生类
public class Student {
    // 静态方法，是和类一起加载的
    public static void say(){
        System.out.println("学生说话");
    }
    // 非静态方法，类实例化之后才存在
    public void sayHello(){
        System.out.println("HelloWorld!");
    }
}

形参和实参

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

值传递和引用传递

// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);      // 结果为1
        Demo04.change(a);
        System.out.println(a);      // 结果还是为1

    }
    // 返回值为空void
    public static void change(int a){
        a = 10;
    }
}

// 引用传递：对象
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);    // 值为Null
        Demo05.change(person);
        System.out.println(person.name);    // 结果为admin
    }
    public static void change(Person person){
        // person是一个对象，可以改变值
        person.name = "admin";
    }
}
class Person{
    String name;
}

三，类与对象的创建

1，类和对象的关系

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

2，创建与初始化对象

使用关键字new创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 1，必须和类的名字相同
- 2，必须没有返回类型，也不能写void

package oop.Demo02;

public class Application {
    // 一个项目应该只有一个main()方法
    public static void main(String[] args) {
        // 类是抽象的，需要实例化，类实例化后会返回一个自己的对象
        Student stu = new Student();    // stu对象就是类Student的一个具体实例
        Student xm = new Student();     //可以创建不同的实例
        Student xh = new Student();
        xm.name = "小明";     // 给对象实例的属性赋值
        xm.age = 16;
        System.out.println(xm.name);
        System.out.println(xm.age);
        System.out.println(xh.name);
        System.out.println(xh.age);
    }
}

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

四，构造器详解

构造器的方法名和类名相同
默认没有返回值
new本质是在调用构造器方法
用于初始化对象的值
如果定义了有参数的构造器方法，必须显式的定义一个无参数的构造器方法

package oop.Demo02;

public class Application {
    // 一个项目应该只有一个main()方法
    public static void main(String[] args) {
        Person student = new Person();   // new实例化一个对象
        System.out.println(student.name);       // 输出无参数构造器默认值student
        Person teacher = new Person("teacher"); // 传入参数
        System.out.println(teacher.name);   // 使用带参数的构造器
    }
}

package oop.Demo02;

public class Person {
    // 一个类即使什么都不写，也会存在一个方法（构造器），给初始值Null
    String name;
    // 可以显式的定义构造器，用于实例化初始值（方法名和类名相同）
    public Person(){
        this.name = "student";
    }
    // 如果定义了下方有参数的构造器，就必须定义上方的无参数构造器
    public Person(String name){
        this.name = name;
    }
}

五、封装

该露的露，该藏的藏
我们程序设计要追求”高内聚，低耦合“，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合就是仅暴露少量的方法给外部使用。
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了：属性私有，get/set

可以通过Alt+Insert快捷键，选择“Getter and Setter"，可以快速生成get/set方法。

package oop.Demo04;

import oop.Demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("student");    // 设置属性
        System.out.println(stu1.getName()); // 获取属性
    }
}

package oop.Demo04;

public class Student {
    // 属性私有
    private String name;
    private int age;
    private char sex;
    // 提供外部可以操作的方法
    // get 获取属性
    public String getName(){
        return this.name;
    }
    // set 设置属性
    public void setName(String name){
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0){
            this.age = 3;
        }
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

六、继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是扩展，子类是父类的扩展。
JAVA中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有 is a 的关系。

package oop.Demo05;

public class Person {
    public int money = 10_0000_0000;
    public void say() {
        System.out.println("说了一句话");
    }
}

package oop.Demo05;

public class Student extends Person {
}

package oop.Demo05;

public class Application {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.say();  // 继承了父类的方法
        System.out.println(stu.money);  //继承了父类的公共属性
    }
}

object类，所有类都默认继承了object类，（ Ctrl + H 快捷键，可以看到类的树形结构。）
super
- super调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中
- super和this 不能同时调用构造方法
- VS this：
  - this：本身调用者这个对象
  - super：代表父类对象的应用
- 前提：
  - this：没有继承也可以使用
  - super：只能在继承条件才可以使用
- 构造方法：
  - this()：本类的构造
  - super()：父类的构造

package oop.Demo05;

public class Application {
    public static void main(String[] args) {
        Student stu = new Student();
        //stu.test("test");
        stu.test1();
    }
}

package oop.Demo05;

public class Person {
    protected String name = "person";
    public void print(){
        System.out.println("person");
    }
}

package oop.Demo05;

public class Student extends Person {
    private String name = "student";

    public void test1(){
        print();
        this.print();   // 子类的方法
        super.print();  // 父类的方法
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);      // 子类的属性
        System.out.println(super.name);     // 父类的属性
    }
    public void print(){
        System.out.println("student");
    }
}

方法重写
- 重写需要有继承关系，子类重写父类的方法
- 重写都是方法的重写
- 子类和父类的方法名必须相同，方法体可以不同
- 参数列表必须相同，否则是方法重载
- 修饰符：范围可以扩大，public > protected > default > private
- 抛出的异常：范围可以被缩小，不能扩大

静态方法stacic *

ackage oop.Demo05;

public class Application {
    public static void main(String[] args) {
        // 静态方法，方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();       // 输出结果A-test()
        // 父类的引用指向了子类
        B b = new A();
        b.test();       // 输出结果B-test()
    }
}

package oop.Demo05;

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

package oop.Demo05;

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

非静态方法，子类重写了父类的方法 *

package oop.Demo05;

public class Application {
    public static void main(String[] args) {
        // 方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();       // 输出结果A-test()
        // 父类的引用指向了子类
        B b = new A();
        b.test();       // 输出结果也是A-test()
    }
}

package oop.Demo05;

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

package oop.Demo05;

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

七、多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用类型有多种
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
多态注意事项：
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系
- 存在的条件：继承关系，方法需要重写，父类引用指向子类对象
  - static方法，属于类，不属于实例，不能重写方法
  - final属于常量，也不能重写方法
  - private私有的，也不能重写

package oop.Demo06;

public class Application {
    public static void main(String[] args) {
        // 一个对象的实际类型是确定的，右边new，而左侧的引用类型可以不确定
        Student s1 = new Student();
        Person s2 = new Student();      // 父类的引用指向子类，new子类
        // 对象能执行哪些方法，与左侧引用有关
        s2.run();       // 引用父类中的run方法，子类重写了父类的方法，则执行子类的方法
        s1.run();
        s1.eat();
        // s2.eat();Person s2不能调用子类独有的eat方法
    }
}

package oop.Demo06;

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

package oop.Demo06;

public class Student extends Person{
    // 重写父类的方法
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

1. instanceof

package oop.Demo06;

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

        // System.out.println(x instanceof y);  // x 和 y 之间是否存在父子关系
        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);       // 没有关系，编译报错
    }
}

package oop.Demo06;

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

package oop.Demo06;

public class Teacher extends Person{
}

package oop.Demo06;

public class Student extends Person{
}

2. 类型转换

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

package oop.Demo06;

public class Application {
    public static void main(String[] args) {
        // 类型之间的转换
        Person obj = new Student();     // obj是Person类型
        // 将obj转换为Student类型
        Student student = (Student)obj;
        student.go();
        // 或者
        ((Student)obj).go();
    }
}

package oop.Demo06;

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

package oop.Demo06;

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

3、static关键字

package oop.Demo07;

public class Student {
    private static int age;     // 静态变量
    private double score;       // 非静态变量
    // 非静态方法
    public void run(){

    }
    // 静态方法
    public static void go(){

    }
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(age);    // 静态变量可以直接用
        System.out.println(s1.score);   // 非静态变量不能直接用
        go();   // 可以直接使用静态方法
        s1.run();   // 非静态方法不能直接用
    }
}

package oop.Demo07;

public class Person {
    {
        System.out.println("匿名代码块，用来赋初始值");
    }
    static {
        System.out.println("静态代码块，只执行一次");    // 静态代码块，只会执行一次
    }
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();  // 第一次可以执行静态代码块
        System.out.println("=============");
        Person person2 = new Person();  // 不会再执行静态代码块
    }
}

八、抽象类

abstract修饰符可以用来修饰方法，也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，该方法就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用 new 关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类，没有实现的抽象方法，否则该子类也要声明为抽象类。
特点：
- 不能new这个抽象类，只能靠子类去实现抽象类中的方法
- 抽象类中可以写普通的方法
- 抽象方法必须在抽象类中

package oop.Demo08;
// 抽象类
public abstract class Action {
    // 抽象方法，只有方法名，没有方法体
    public abstract void run();
}

package oop.Demo08;
// 抽象类的子类，必须实现父类的所有方法
public class A extends Action{
    public void run(){

    }
}

九、接口

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

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是……则必须能……”的思想。如果你是汽车，则必须能跑。
接口的本质是契约，就像法律一样，指定好后大家都要遵守。
面向对象（OO）的精髓，是对对象的抽象，最能体现这一点的就是接口。

1.接口的作用：

约束
定义一些方法，让不同的人实现
接口中的方法默认都是 public abstract
接口中的变量默认都是 public static final
接口不能被实例化，接口中没有构造方法
接口可以实现多个继承，implements关键字
必须要重写接口中的方法

package oop.Demo09;
//定义接口
public interface User {
    void run(String name);
    void add(String name);
    void update(String name);
    void delete(String name);
}

package oop.Demo09;

public interface Time {
    void timer();
}

package oop.Demo09;
// 实现接口 implemets 接口名 (可以继承多个接口)
public class UserImpl implements User,Time{
    // 实现了接口的类，九必须重写接口中的方法

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void run(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void timer() {

    }
}

十、内部类

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

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

package oop.Demo10;

public class Application {
    public static void main(String[] args) {
        Outer out = new Outer();      // 实例化外部类
        Outer.Inner in = out.new Inner();      // 实例化内部类
        in.getID();     //
    }
}

package oop.Demo10;

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);
        }
    }
    public void method(){
        // 方法中的局部内部类
        class A{

        }
    }
}
// 一个类文件中只能有一个public类
class B{

}

posted @ 2023-01-01 20:47 红妹妹阅读(23) 评论(0) 收藏举报

刷新页面返回顶部