JavaSE面向对象

构造器详解

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

类中构造器也称构造方法，是在进行创建对象的时候必须调用的。 并且构造器有以下两个特点

1.必须和类的名字相同

2.必须没有返回类型，也不能写void

构造器：

​ 1.和类名相同

​ 2.没有返回值

作用：

​ 1.new 本质是在调用构造方法

​ 2.初始化对象的值

注意点：

​ 1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造

​ Alt + Insert

​ this. =

public class Person{
    //一个类及时什么都不写，它也会存在一个方法。显示的定义方法
    //显示的定义构造器
    String name;
    int age;
    
    //alt + insert
    
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person{
        //this.name = "qinjiang"
        
    }
}

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



}

public class Application{
    public  static void main(String[] args){
        
        //new 实例化了一个对象
        
        Person person = new Person("Roman,age"); person:Person@524
        
        System.out.println(person.name);//qinjiang
    
}
}

面向对象006：创建对象内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H0nbxeju-1622551066811)(C:\Users\李少浦\AppData\Roaming\Typora\typora-user-images\image-20210531192150735.png)]

面向对象07：简单小结类与对象

public  static void main (String[] args){
/*
1.类与对象
	类是一个模板：抽象，对象是一个具体的实例
2.方法
	定义，调用
3.对象的引用
	引用类型：基本类型(8)
	对象是通过引用来操作的：栈--》堆

4.属性：字段Field 成员变量
	默认初始化
		数字：0 0.0
		char：u000
		boolean：false
		引用：null
		
		修饰符 属性类型 属性名 = 属性值！
5.对象的创建和使用
	- 必须使用new 关键字创建对象，构造器 Person Roman = new Person();
	- 对象的属性 Roman.name
	- 对象的方法 Roman.sleep()
	
6.类
	静态的属性  属性
	动态的行为  方法
	
	封装、继承、多态
*/

}

面向对象08：封装详解

封装

我们程序设计要追求“高内聚，低耦合”，高内聚就是内部数据操作细节自己完成，不允许外部干涉;低耦合，仅暴露少量的方法给外部使用


比如银行只能通过用户取自己的钱 你可以操作银行的钱吗？ 你可以把银行的钱借给别人吗？ 方法仅仅围绕自己的银行卡进行操作

封装(数据的隐藏)

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

属性私有，get/set

代码

public class Student {
    //需求分析 创建两个类 一个测试类调用方法 一个类负责封装代码 实现隐藏代码细节
    //创建一个类 负责写属性
    //创建一个类负责获得和修改数据
    //在写一个判断方法 判断用户年龄是否输入有误


    String name; //名字

    int age; //年龄

    int gongzi; //工资


    public String getName() {

        return this.name;

    }

    public void setName(String name) {

        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getGongzi() {
        return gongzi;
    }

    public void setGongzi(int gongzi) {
        this.gongzi = gongzi;
    }
}

package com.Roman.oop.fengzhuang;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student(); //声明一个Student的对象并命名s1
        s1.setName("Roman"); //设置属性时是括号 设置名字是set
        s1.setAge(10);
        s1.setGongzi(10000);
        System.out.println(s1.getName()); //获得名字是get
        System.out.println(s1.getAge());
        System.out.println(s1.gongzi);

        Student s2 = new Student();
        s2.setName("ming");
        s2.setAge(10);
        s2.setGongzi(300);
        System.out.println(s2.getName()); //获得名字是get
        System.out.println(s2.getAge());
        System.out.println(s2.getGongzi());
    }


}

package oop.demo04.demo04;

//类 privare： 属性私有
public class Studnet { //声明一个类


    //属性私有就是外部的人new也没有办法使用
    private String name; //名字 创建name变量

    private int id;  //学号 创建id变量

    private int specialty; //专业

    private char sex; //性别

    private int age; //年龄

    //getset就是给属性一些可以操作的方法
    //提供一些public的get、set方法
    //get就是获得这个属性


    //命名遵循驼峰命名规则
    public String getName(){ //创建一个返回String类型的方法
        return this.name; //返回这个方法的名字 //方法做的事情
    }

    //set就是给这个属性设置值
    public void setName(String name){ //这个地方一定要有形式参数，方便调用

        this.name = name;//这个name就等于Roman 上面的getName方法的 name就被赋值了
    }

    //alt +insert 自动生成get、set的方法

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getSpecialty() {
        return specialty;
    }

    public void setSpecialty(int specialty) {
        this.specialty = specialty;
    }

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    //由于已经封装过了 所以可以进行安全性检查
    //可以通过内部的封装让程序变得更安全
    public void setAge(int age) { //方法判断输入年龄是否有误
        if(age > 0 || age < 120 ){
         this.age = 3;
        }
         else{
        this.age = age;
        }
    }
}

​
​ Application main方法

package oop.demo04;

import oop.demo04.demo04.Studnet;
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统的可维护性增加
 */
public class Application {
    public static void main(String[] args) {
        Studnet s1 = new Studnet();
        //可以调用公共方法
        s1.setName("Roman");

        //方法的重载 为什么println可以输出这些东西 我们可以看看源码
        //在类里面，假设有很多方法相同的名称，但是参数变量不同，这就是方法重载
        System.out.println(s1.getName());

        s1.setAge(-1); //不合法的数据 可以使用set方法规避掉
        System.out.println(s1.getAge());


    }
}

面向对象09：什么是继承

继承

继承的本质是对某一批类的抽象 从而实现对现实世界的建模

extands的意思是扩展 子类是父类的继承

java只有单继承 没有多继承 一个儿子只有一个爸爸，爸爸可以有多个儿子

继承是类和类之间的一种关系。除此之外 ，类和类之间的关系还有依赖、组合、聚合等

继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extendes表示

子类和父类之间，从意义上讲具有 is a 的关系

object 类

super 类

方法重写

代码

package oop.demo05;

//在Java中，所有的类，都默认直接或者间接继承Object类
//Person 人 继承是最核心的 多态也是有继承的前提
public class Person /*extends Object*/{
/*
    //优先级最高的是public
    //public是公共的
    //default默认的
    //protected受保护的
    //private私有的
    //这是父亲类私有的，子类无法继承，私有的是无法继承的
    //你无法直接操作我的钱，但是你可以通过我的方法来进行操作
    private int money = 10_0000_0000;

    //子类可以继承父类的所有方法

    public void say(){
        System.out.println("和同桌说了一句悄悄话");

    }

    public int getMoney() {
        return money;
    }

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


    }
    */

}

package oop.demo05;//学生 is 人 :派生类，子类//子类继承了父类，就会拥有全部的方法public class Student extends Person { //学生继承了人    //也可以通过组合 Person person;}

package oop.demo05;//Teacher is 人:派生类，子类 相当于父类下面的一些类public class Teacher extends Person {  //Teacher继承了Person}

package oop;import oop.demo05.Person;import oop.demo05.Student;public class Application {    public static void main(String[] args) {/*        Student student = new Student();        //正常情况是什么都点不出来的，它是个无参构造        //为什么可以运行，因为Student类继承了Person类的方法。子类继承了父类就会拥有父类的全部方法        student.say();        System.out.println(student.money);        */        Person person = new Person();        person.getClass();    }}

面向对象10：Super详解

super注意点：

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

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

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

VS this：

​ 代表的对象不同：

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

​ super：代表父类对象的引用

​ 前提

​ this：没有继承也可以使用

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

构造方法：

​ this()；本类的构造

​ super(); 父类的构造

public class Application{    public static void main(String[] args){        //Person person = new Person();                Student student = new Student();        //stuent.test("Roman");       // student.test1();    }}

// 学生 is 人： 派生类，子类// 子类继承了父类，就会拥有父类的全部方法!public class Student extends Person{                       public Student(){            //隐藏代码：调用了父类的无参构造            super(); //调用了父类的构造器，必须要在子类的第一行            //this("hello");        System.out.println("Student被无参执行了");    }        public Student(String name){        this.name = name;    }         private String name = "q"                public void print(){        System.out.println("Student");    }                public void test1(String name){        System.out.println(name); //Roman        System.out.println(this.name); //q        System.out.println(super.name); //k                    }                    public void test2(String name){        print(); //Student        this.print(); //Student        super.print(); //Person                    }}

//在Java中，所有的类，都默认直接或者间接继承Object//Person 人：父类public class Person /*extends Objects*/{        public Person() {        System.out.println("Person无参执行了");    }        protected String name = "k";        //私有的东西无法被继承!    public void print(){        System.out.println("Person")    }       }    

面向对象11：方法重写

重写：需要有继承的关系，子类重写了父类的方法！

​ 1.方法名必须相同

​ 2.参数列表列表必须相同

​ 3.修饰符：范围可以扩大但不能缩小： public>Protected>Default>private

​ 4.抛出的异常：范围,可以被缩小,但不能放大：ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必要一致：方法体不同!

为什么要重写：

​ 1.父类的功能，子类不一定需要，或者不一定满足

​ ALT + INSERT override;

//静态的方法和非静态的方法区别很大//静态方法：方法的调用只能和左边,定义的构造器public static void main(String[] args){        //方法的调用只能和左边，定义的数据类型有关    A a = new A();    a.test(); //A        //父类的引用指向了子类    B b = new A(); //子类重写了父类的方法    b.test(); //B}

//继承public class extends B{        //@Override 重写    @Override //注解：有功能的注释    public void test(){        //System.out.println("A=>test()")        super.test();    }}

//重写都是方法的重写，和属性无关public class B{        public void test(){		System.out.println("B>=test");    }}

面向对象12：什么是多态

即同一方法可以根据发送对象的不同而采用多种不同的行为模式

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

多态存在的条件

​ 有继承关系

​ 子类重写父类的方法

​ 父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

instanceof

面向对象13：instanceof(引用类型)，判断一个对象是什么类型

判断两个类之间是否存在父子关系，有父子关系就行

package com.lsp.oop.demo02;

//java文件编译后会生成class文件
//java编译后的文件后缀名变成了class文件 并且默认加上了public Person(){}
//方法名和类名相同这就是构造器
public class Person {

//一个类即使什么都不写，它也会存在一个方法
//构造方法的特点：
    //必须和类名相同
    //必须没有返回类型，也不能写void

//显示定义的构造器

String name;
int age;

//构造器的第一个作用就是实例化初始值 new对象的时候会进入这个方法
//使用new关键字，必须要有构造器
//1.使用new关键字，本质是在调用构造器
//2.用来初始化值
public  Person(){
    //无参构造
    this.name = "lsp";
}

//有参构造：一旦定义了有参构造，无参构造就必须显示
//new一个对象本质是在调用构造器
public Person(String name){ //这个name=下面那个name传递上来

    this.name = name;
}

//alt + insert 一键生成有参无参


public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

}

/*
public static void main(String[] args) {

    //使用new关键词实例化对象
    Person person = new Person("lsp",18);

    System.out.println(person.name);

}

构造器：
    1.和类名相同
    2.没有返回值
 作用：
     1.new 本质是在调用构造方法
     2.初始化对象的值
 注意点：
    1.定义了有参构造之后，如果想使用无参构造，必须显示定义的有参构造
    
    alt+insert
    this.代表当前类的 后面的值一般是参数传进来的

*/