投稿
  1. 首页
  2. 随笔

java面向对象04

巴尔扎克名言 • 2022-12-11 • 随笔 • 阅读 10

java面向对象04,第1张

java面向对象04 面向过程&面向对象
  • 面向过程思想
    • 步骤清晰简单
    • 适合处理一些较为简单的问题
  • 面向对象思想
    • 分类的思考模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行简单独立思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面型对象适合处理复杂的问题，适合处理需要多人协作的问题。

总结：对于复杂事物，为了从宏观上把控，从整体上合理分析，需要以面向对象的思路来分析整个系统，但是，具体到微观 *** 作，仍然需要面向过程的思路去处理。

面向对象

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

三大特征：1）封装 2）继承 3）多态

构造器详解 
package oop;

public class Demo01 {
    public static void main(String[] args) {
        Person person = new Person();
        Person ljh = new Person("ljh");

        System.out.println(person.name);
        System.out.println(ljh);
    }
}

package oop;

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

    }

    //有参构造
    public Person(String name){
        this.name=name;
    }

    

}
封装
  • 设计追求”高内聚，低耦合“。
package oop;



import oop.demo03.Student;

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

        Student s1 = new Student();
        s1.setName("ljh");
        //String name = s1.getName();
        System.out.println(s1.getName());

    }
}

package oop.demo03;

public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;

    //提供一些可以 *** 作这个属性的方法
    //提供一些public的get、set方法

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
继承
  • 继承的本质是对某一类对象的抽象，从而实现对现实世界更好的建模。
  • extends的意思是“扩展”，子类是父类的扩展。
  • JAVA中类只有单继承，没有多继承。（一个儿子只能有一个爸爸，一个爸爸可以有很多儿子）
  • 继承是类和类之间的关系，除此之外还有依赖、组合、聚合等关系。
  • 子类和父类之间，从意义上讲应该具有“is a”的关系。

1)Object类

package oop;


import oop.demo04.Student;

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

        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());


    }
}

package oop.demo04;

//Student is Person  子类
public class Student extends Person {

    //ctrl + H 继承树
    //在java中所有的类都默认直接或间接继承Object类
}

package oop.demo04;

//Person 父类
public class Person {

    private int money=1000_0000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

2）继承

package oop;


import oop.demo04.Student;

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

        Student student = new Student();
        student.test("lll");

    }
}


package oop.demo04;

//Student is Person  子类
public class Student extends Person {
    
     public Student(){
        System.out.println("Student执行了");
    }

    //ctrl + H 继承树
    //在java中所有的类都默认直接或间接继承Object类
    private String name = "lj";

    public void test(String name){
        System.out.println(name);  //显示Application中输入的name
        System.out.println(this.name);  //该类中输入的name
        System.out.println(super.name);//调用父类中的name
    }
}


package oop.demo04;

//Person 父类
public class Person {

    public Person(){
        System.out.println("Person执行了");
    }
    protected String name="ljh";
}

结果：

Super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个。

2.super必须只能出现在子类的方法或者构造方法中。

3.super和this不能同时调用构造方法。

Vs this:

代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类

前提：

​ this：没有继承也能使用

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

构造方法：

​ this()：本类的构造

​ super()：父类的构造

3）方法重写

注释：

  • 需要有继承关系，子类重写父类的方法。
    • 方法名必须相同
    • 参数列表必须相同
    • 修饰符：范围可以扩大，但不能缩小
    • 抛出的异常：可以被缩小，但不能扩大
  • 子类和父类方法必须要一致，方法体不同

为什么需要重写：

  • 父类的功能，子类不一定需要，或者不一定满足。
package oop.demo05;

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


    @Override  //重写注释
    public void test() {
        System.out.println("A=>test()");
    }
}

package oop.demo05;

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

package oop.demo04;


import oop.demo05.A;
import oop.demo05.B;

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

        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();

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


    }
}
多态

1）

注意事项：

  • 多态是方法的多态，属性没有多态
  • 父类和子类，有联系
  • 存在条件：继承关系、方法需要重写，父类引用指向子类对象
    • static 方法，属于类，它不属于实例
    • final 常量：
    • private方法：
package oop;


import oop.demo06.Person;
import oop.demo06.Student;

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

        //可以指向的引用类型就不确定了：父类的引用指向子类

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

        s2.run();
        s1.run();
        ((Student) s2).eat();

    }
}

package oop.demo06;

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

package oop.demo06;

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

2）instanceof和类型转换

package oop;


import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        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
    }
}

package oop.demo06;

public class Person {

}

package oop.demo06;

public class Student extends Person {

}

package oop.demo06;

public class Teacher extends Person {
}

结果：

3）总结

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

4）static关键字详解

package oop.demo07;

//static
public class Student {
    private static int age;  //静态的变量  多线程
    private double score;   //非静态的变量

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
      //  System.out.println(Student.score); 非静态字段不能这样使用
        System.out.println(s1.score);
        System.out.println(s1.age);
    }
}
抽象类 
package oop.demo08;

//abstract 抽象类   类 extends： 单继承     （接口可以多继承）
public abstract class Action {
    //abstract ,抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    
}

package oop.demo08;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非~
public class  A extends Action {
    @Override
    public void doSomething() {   //具体的方法

    }
}
接口
  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）都有
  • 接口：只有规范，自己无法写方法~专业的约束！约束和实现分离：面向接口编程

作用：

（1）约束

（2）定义一些方法，让不同的人实现

（3）接口不能被实例化，接口没有构造方法

（4）public abstract

（5）public static final

（6）implements可以实现多个接口

（7）必须要重写接口中的方法

内部类 
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);
       }
    }
}

package oop;

import oop.demo10.Outer;

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

    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/zaji/5434393.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
巴尔扎克名言 巴尔扎克名言 一级用户组
0 0
上一篇 2022-12-11
下一篇 2022-12-11

发表评论

登录后才能评论

评论列表（0条）

保存