javaSE面向对象编程

2021 年 8 月 12 日
笔记
java se学习

面向对象编程

构造器

构造器就是和类名相同但无返回类型的方法。

public class Person {
    //一个类即使什么都不写,它也会存在一个方法
    //显示的定义构造器

    String name;

    //实例化初始值
    //1.使用new关键字,本质是在调用构造器
    //2.用来初始化值
    public Person(){
    }

    //有参构造:一旦定义了有参构造,无参构造就必须显示定义
    public Person(String name){
        this.name = name;
    }

    //alt+insert自动生成构造器
    /*
    public static void main(String[] args) {

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

    }
    构造器:
        1.和类名相同
        2.没用返回值
    作用:
        1.new本质在调用构造方法
        2.初始化对象的值
    注意点:
        1.定义有参构造之后,如果想使用无参构造,就要显示定义一个无参构造
     */
}

无参构造器

public class Pet {
    public String name;
    public int age;

    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }

    /*
    1.类与对象
        类是一个模板:抽象,对象是一个具体的实例

    2.方法
        定义,调用!

    3.对应的引用
        引用类型:   基本类型(8)
        对象是通过引用来操作的: 栈-->堆

    4.属性:字段Field 成员变量
        默认初始化:
            数字:0    0.0
            char:u0000
            boolean:false
            引用:null

    5.对象的创建和使用
        -必须使用new 关键字创造对象,构造器 Person Avirus = new Person();
        -对象的属性  Avirus.name
        -对象的方法  Avirus.sleep();
     */
}

如何访问私有属性

package oop.Demo04;

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

public class Student {

    //属性私有
    private String name; //姓名
    private int id; //学号
    private char sex; //性别

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0){
            System.out.println("不合法");
        }else {
            this.age = age;
        }
    }

    private int age;

    //提供一些可以操作这个属性的方法!
    //提供一些public的get,set方法

    //get获取这个数据
    public String getName(){
        return this.name;
    }

    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    //alt + insert
}

封装

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

package oop.Demo04;

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

public class Student {

    //属性私有
    private String name; //姓名
    private int id; //学号
    private char sex; //性别

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0){
            System.out.println("不合法");
        }else {
            this.age = age;
        }
    }

    private int age;

    //提供一些可以操作这个属性的方法!
    //提供一些public的get,set方法

    //get获取这个数据
    public String getName(){
        return this.name;
    }

    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    //alt + insert
}

继承

继承得本质是堆某一批类得抽象,从而实现对现实世界更好得建模
extends得意思是”扩展”.子类是父类得扩展
Java中类只有单继承,没有多继承!
继承是类和类之间得一直关系.除此之外,类和类之间得关系还有依赖,组合,聚合等.
继承关系得两个类,一个为子类(派生类),一个为父类(基类).子类继承父类,使用关键字extands来表示
子类和父类之间,从意义上讲应该具有”is a”得关系
object类
super
方法重写

//所有类都继承了Object类
public class Person {
    //private
    //protected
    //public
    private int money = 10000000;


    public int getMoney() {
        return money;
    }

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

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

public class Student extends Person{
    
}

继承了父类得子类,可以使用父类中得方法

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

这个地方值得注意的是被final关键字修饰的类,就不能被继承

super

super关键字是用来调用父类的属性和方法

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

    public Student() {
        //隐藏代码super();
        super();//调用父类得构造器,必须在子类得第一行
        System.out.println("Student无参执行");
    }

    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();
    }
    public void print(){
        System.out.println("Student");
    }
}

super注意点

super注意点:
    1.super调用父类得构造器方法,必须在构造器方法得第一个
    2.super必须只能出现在子类得方法或者构造方法中!
    3.super和this不能同时调用构造方法!


Vs this:
    代表得对象不同:
        this: 本身调用这个对象
        super: 代表父类对象得应用

    前提
        this:没用继承也可以使用
        super:只能在继承条件下使用

    构造方法
        this():本类的构造
        super():父类的构造
        
在子类如果想调用父类的无参构造器时,父类要写无参构造器,子类也可以直接调用父类的有参构造,在super里面直接加参数.
如果父类里面只有有参构造器,而没有无参构造器,子类无法调用父类的无参构造器

方法重写

//重写是方法的重写,与属性无关
public class B {
    //静态方法和非静态方法区别很大
        //方法的调用之后,左边定义的数据类型有关

    //非静态:重写
    public void test(){
        System.out.println("B-->test()");
    }
}

重写:需要在继承关系,子类重写父类的方法!
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符:范围可以扩大,但不可以缩小:public>protected>default>private
    4.抛出的异常:范围可以缩小,但是不能扩大
是在非静态方法下的
重写,子类的方法和父类必须要一致,方法体不同!
    1.父类的功能,子类不一定需要,也不一定满足
    alt+insert: override
    
在自动生成的重写方法上面会有一个注解

多态

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

/*
多态注意事项:
1.  多态是方法的多态,属性没用多态
2.  父类和子类,有联系,没有联系会类型转换异常! ClassCastException!
3.  存在条件: 继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();

    1.static 方法,属于类,它不属于实例
    2.final 常量
    3.private方法





//一个对象的实际类型是确定的

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

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

        //对象能执行哪些方法,主要看对象右边的类型,和右边关系不大
        s2.run(); //子类重写了父类的方法,执行子类的方法
        s1.run();
 */

类型转换

/*
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型
3.把父类转换为子类,向下转型,强制转换,可能会丢失一些方法(说的是丢失子类特殊的方法)
4.方便方法的调用,减少重复的代码
*/
/*//类型之间的转换: 父      子

        //高                     低


        //student将这个对象转换为Student类型,我们就可以使用Student类型的方法了!


        //子类转换为父类,可能丢失自己的本来的一些方法!
        Student student = new Student();
        student.go();*/

static关键字

被static修饰过之后,与类一起加载,所以被第一个调用

public class Teacher {

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

    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        System.out.println("===================");
        Teacher teacher2 = new Teacher();
    }
}

静态导入包

//静态导入包
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);
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

//抽象类的所有方法,继承了它的子类,都必须要实现它的方法  除非它自己也是一个抽象类
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

//abstract抽象类  单继承           {接口可以多继承}
public abstract class Action {

    //约束~有人帮我们实现~
    //abstract ,抽象方法 ,只有方法名,没用方法的实现
    public abstract void doSomething();

    //1.不能new这个抽象类,只能靠子类区实现它:约束!
    public void hello(){
        
    }//抽象类中有普通方法是可以的
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象:约束

    //思考? new,存在构造器么?
    //抽象类是存在构造器的,不然子类无法重写方法
            //存在的意义     抽象出来~提高开发效率
}

接口

普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法_{专业的约束!约束和实现分离:面向接口编程}
接口就是规范，定义的是- -组规则，体现了现实世界中“如果你…则必须能..的思想。如果你是天使,
则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。
接口的本质是契约，就像我们人间的法律-样。制定好后大家都遵守。
00P的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象
能力的语言(比如C++、 java、 c#等) ,就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class,声明接[的关键字是interface

一个接口

//抽象的思维~ Java 架构

//interface定义的关键字,  接口都需要实现类
public interface UserService {

    //常量 public static final
    int AGE = 99;

    //接口中的所有定义的方法其实都是抽象的   public abstract默认
    void run();
    void add(String name);
    void delete(String name);
    void update(String name);
    void select(String name);
}

实现类

//抽象类: extends~
//类 可以实现接口 implements 接口
//实现了接口的类,就需要重写接口中的方法~

//多继承,利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void run() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void select(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

public class Outer {

    private int ID = 10;

    public void Outer(){
        System.out.println("Out!");
    }

    //局部内部类
    public void method(){
        class test{
            public void tst(){

            }
        }
    }

    public class Inner{
        public void in(){
            System.out.println("In!");
        }

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

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

interface Avirus{
    void hello();
}

Tags: java se学习

javaSE面向对象编程

面向对象编程

构造器

如何访问私有属性

封装

继承

super

方法重写

多态

类型转换

static关键字

抽象类

接口

内部类

VirMach 便宜 VPS

QNews

javaSE面向对象编程

面向对象编程

构造器

如何访问私有属性

封装

继承

super

方法重写

多态

类型转换

static关键字

抽象类

接口

内部类

分享此文：

Related Posts

R语言从入门到精通：Day8

好文分享|一文带你搞清楚什么是“数据倾斜”

Spring Boot 入门系列（二十二）使用Swagger2构建 RESTful API文档

3D性能优化 | 说一说glTF文件压缩

VirMach 便宜 VPS

QNews

热门文章

热门搜寻