第六章、面向对象编程-CSDN博客

本文链接：https://blog.csdn.net/hbxrm/article/details/117602221

一、方法的定义和调用

在一个java源文件中，可以声明多个class。但是，最多只能有一个类声明为public。而且声明为public的类的类名，必须与源文件名相同。

1、方法的声明格式

[权限修饰符]  返回值类型  方法名（形式参数类型  形式参数名）{

        多个Java语句;

        return  返回值;

}

public class TestMethod {

    public static void main(String[] args) {

        int num1=10;
        int num2=20;
        int sum=add(num1,num2);

        System.out.println("两数之和是："+sum);

        printInfo();

    }

    //求两数之和
    public static int add(int num1,int num2){
        int sum=num1+num2;
        return sum;
    }

    //打印公司信息
    public static void printInfo(){
        System.out.println("明日科技有限公司");
    }
}

二、方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时会根据不同的参数自动匹配对应的方法。

重载的方法，实际是完全不同的方法，只是名称相同而已。

2.1、构成方法重载的条件

1、形参列表不同：形参类型、形参个数、形参的顺序不同。

2、如果只有返回值不同，不构成方法的重载。
   如：int a(String str){}与void a(String str){}不构成方法重载

3、只有形参的名称不同，不构成方法的重载。
   如：int a(String str){}与int a(String s){}不构成方法重载

/**
 * 方法的重载
 */
public class TestOverLoad {
    public static void main(String[] args) {
        add(100,200);
        add(100.1,200);
        add(100,200,300);
        add(200,100.1);
    }
    /**求和的方法*/
    public static int add(int n1,int n2){
        int sum=n1+n2;
        return sum;
    }
    //方法名相同，形参类型不同，构成重载
    public static double add(double n1,int n2){
        double sum=n1+n2;
        return sum;
    }
    //方法名相同，形参个数不同，构成重载
    public static int add(int n1,int n2,int n3){
        int sum=n1+n2+n3;
        return sum;
    }
    //方法名相同，形参顺序不同，构成重载
    public static double add(int n1,double n2){
        double sum=n1+n2;
        return sum;
    }
}

三、类

1、类的定义

三个常见成员	作用
成员变量/属性 field	静态特征（数据）
方法 method	动态行为（对数据的操作）
构造方法/构造器 constructor	初始化对象

2、成员变量的默认值

数据类型	默认值
整形	0
浮点型	0.0
字符型	'\u0000'
布尔型	false
所有引用类型	null

public class Computer {

    String brand;   //品牌
    int price;      //价格

}

public class BaizhanStudent {

    int id;
    String sName;
    int age;
    Computer computer;

    void study(){
        System.out.println("我正在学习！使用的电脑是："+computer.brand);
    }

    public static void main(String[] args) {

        Computer c1=new Computer();
        c1.brand="联想";
        c1.price=6000;

        Computer c2=new Computer();
        c2.brand="dell";
        c2.price=5000;

        BaizhanStudent stu1=new BaizhanStudent();
        stu1.id=1001;
        stu1.sName="高琪";
        stu1.age=18;
        stu1.computer=c1;

        stu1.study();
    }
}

四、构造方法

1、构造方法的核心作用：

用于对象的初始化。Java通过new关键字来调用构造方法，它是一种特殊的方法。

2、构造方法的声明格式：

[修饰符]  类名  （形参列表）{

    Java语句;

}

3、构造方法的4个要点：

1、构造方法通过new关键字来调用。

2、构造方法虽然有返回值，但是不能定义返回值类型（返回值类型肯定是本类），不能在构造方法里使用return返回某个值。

3、如果我们没有定义构造方法，则编译器会自动定义一个无参的构造方法。如果已定义则编译器不会自动添加。

4、构造方法的方法名必须和类名一致。

4、构造方法的重载

构造方法也是方法，只不过有特殊的作用而已，与普通方法一样，构造方法也可以重载。

五、创建对象的四大步

1、分配对象空间，并将对象成员变量初始化为0或空。

2、执行属性值的显示初始化。

3、执行构造方法，初始化对象。

4、返回对象的地址给相关的变量。

六、栈和堆

public class Person {

    String name;
    int age;

    public void show(){
        System.out.println("姓名:"+name+"\t年龄："+age);
    }

    public Person(){

    }

    public Person(String _name,int _age){
        name=_name;
        age=_age;
    }

    public static void main(String[] args) {
        Person p1=new Person();
        p1.name="张三";
        p1.age=24;
        p1.show();

        Person p2=new Person("李四",30);
        p2.show();

    }
}

第一步：

第二步：

七、this的本质

1、this的本质

public class User2 {

    int id;
    String name;
    String pwd;

    public User2 (){

    }

    public User2(int id,String name){
        System.out.println("正在要初始化的对象是："+this);
        this.id=id;
        this.name=name;
    }

    public void login(){
        System.out.println("要登陆："+this.name+",密码是："+this.pwd);
    }

    public static void main(String[] args) {
        User2 u=new User2(101,"高小琪");
        u.login();
    }
}

第一步：

第二步：

2、this()调用重载构造方法

    public User2(int id,String name){
        System.out.println("正在要初始化的对象是："+this);
        this.id=id;
        this.name=name;
    }

    public User2(int id,String name,String pwd){
        this(id,name);      //调用了重载的构造器！这种调用必须位于构造方法的第一行！
        this.pwd=pwd;
    }

八、static的本质

1、static关键字核心用法

public class TestStatic {

    int id;
    static String company="北京尚学堂";

    static void printCompany(){
        System.out.println(company);
    }

    void login(){
        System.out.println("登陆");
    }

    public static void main(String[] args) {
        TestStatic.printCompany();

        TestStatic t1=new TestStatic();
        t1.login();

        TestStatic t2=new TestStatic();
        t2.login();
    }
}

2、static静态初始化块

    static String company="北京尚学堂";
    static int companyId=0;

    //静态初始化块在类被初始化时就调用，执行与main方法之前
    static{
        System.out.println("类被初始化的调用！");
        companyId=00000;
        company="明日科技！";
    }

九、package和import

1、package包机制

新建包

2、import

import static java.lang.Math.random;
import static java.lang.Math.*;

package com.myproject.test3;

import static java.lang.Math.random;

public class Main2 {

    public static void main(String[] args) {

        //Math.random();
        random();
    }
}

十、继承、方法的重写

1、继承的实现

public class TestExtends {

    public static void main(String[] args) {
        Student stu=new Student("高琪",170,"Java");
        stu.rest();
        stu.study();
        System.out.println(stu.name);

        //instanceof判断对象是否是这个类的实例
        System.out.println(stu instanceof Student);
        System.out.println(stu instanceof Person);
    }
}

class Person {
    String name;
    int height;

    public void rest(){
        System.out.println("休息一会！");
    }
}

class Student extends Person{
    String major;

    public void study(){
        System.out.println("Student.study");
    }

    public Student(String name,int height,String major){
        this.name=name;
        this.height=height;
        this.major=major;
    }
}

2、方法的重写

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

    public void stop(){
        System.out.println("stop..");
    }

}

class Plane extends Vehicle{
    public void run(){
        System.out.println("天上飞...");
    }

    public void stop(){
        System.out.println("在机场停，不能在天上停");
    }
}

3、final关键字

4、继承和组合

/**
 * 测试组合
 */
public class TestComposition {
    public static void main(String[] args) {
        Stu stu=new Stu("李琦",170,"Java");
        stu.person.rest();    //调用相当于父类对象的方法
        System.out.println(stu.person.name);
        System.out.println(stu.person.height);
        System.out.println(stu.major);
    }
}

class Stu /*此处没有使用extends,即没有使用继承*/{

    Person person=new Person();    //定义一个相当于父类对象
    String major;

    public void study(){
        System.out.println("Stu.study");
    }

    //定义一个构造器
    public Stu(String name,int height,String major){
        //调用这个相当于父类对象的属性
        this.person.name=name;
        this.person.height=height;

        this.major=major;
    }
}

例如：学生是人类，使用继承；计算机拥有CPU、Memory，使用组合。

十一、Object类、重写toString()方法、重写equals()方法

import java.util.Objects;

/**
 * 测试Object的用法
 */
public class TestObject {
    public static void main(String[] args) {

        Employee e1=new Employee(1001,"张三");
        Employee e2=new Employee(1001,"李四");
        System.out.println(e1.toString()); //打印对象默认调用的是toString()方法

        System.out.println(e1==e2);     //比较两个对象是否相同
        System.out.println(e1.equals(e2));//两个对象是否相等（逻辑上进行某些值的比较）
    }
}

class Employee extends Object{
    int id;
    String name;

    //创建一个构造器
    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    //重写Object的toString()方法
    @Override
    public String toString() {
        return "雇员编号："+id+"，姓名："+name;
    }

    //重写Object的equas()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

十二、super和继承内存分析

public class TestSuper {
    public static void main(String[] args) {
        Child child=new Child();
        child.show();
    }
}

class Parent {
    int num=300;
    public Parent(){
        //super();     //默认调用Object的构造方法
        System.out.println("初始化父类对象！");
    }
    public void show(){
        System.out.println("父类中的show()方法");
    }
}

class Child extends Parent{
    int num=1000;
    public Child() {
        super();    //即使没有写此句，也会默认调用父类构造方法
        System.out.println("初始化子类对象！");
    }
    @Override
    public void show() {
        System.out.println("子类中的show()方法");
        super.show();
        System.out.println("子类中的num="+num);
        System.out.println("父类中的num="+super.num);
    }
}

十三、封装

1、封装的实现

package com.myproject.encapsulation.a;

public class User {

    private int id;
    private String name;
    private String pwd;
    private boolean admin;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public boolean isAdmin() {
        return admin;
    }

    public void setAdmin(boolean admin) {
        this.admin = admin;
    }

    public void login(){
        System.out.println("User.login");
    }

}

十四、多态、对象的转型

1、多态的核心要点

public class TestDuoTai {

    public static void main(String[] args) {

        Dog d=new Dog();
        animalCry(d);

        Cat c=new Cat();
        animalCry(c);

        //对象的转型
        Animal a=new Dog();
        a.shout();
        //a.watchDoor();

        //强制转型
        Dog a2=(Dog)a;
        a2.watchDoor();

        //Cat a3=(Cat)a;    //  运行时报错
    }

    static void animalCry(Animal a){
        a.shout();      //多态的三个必要条件：继承、方法的重写、父类引用指点向子类对象
    }
}

class Animal {

    public void shout(){
        System.out.println("Animal.shout");
    }
}

class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪！");
    }
}

class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵！");
    }
}

十五、抽象类和抽象方法

1、抽象方法和抽象类

//模版方法模式（其实就是抽象类的应用）
public abstract class DBOperator {

    //1.建立连接  2.打开数据库  3.使用数据库  4.关闭连接
    public abstract void connection();

    public void open(){
        System.out.println("打开数据库");
    }

    public void use(){
        System.out.println("使用数据库");
    }

    public void close(){
        System.out.println("关闭连接");
    }

    public void process(){
        connection();
        open();
        use();
        close();
    }

    public static void main(String[] args) {
        MySQL mysql=new MySQL();
        mysql.process();
    }
}

class MySQL extends DBOperator{

    @Override
    public void connection() {
        System.out.println("建立和MySQL数据库的连接");
    }
}

class Oracle extends DBOperator{
    @Override
    public void connection() {
        System.out.println("建立和Oracle数据库的连接");
    }
}

十六、接口Interface

/**
 * 测试接口的基本语法
 */
public class TestInterface {

    public static void main(String[] args) {

        Angel a=new Angel();
        a.fly();
        a.helpOthers();
                
        Volant birdMan=new BirdMan();
        birdMan.fly();
    }
}

/**
 * 飞行接口
 */
interface Volant{

    int FLY_HEIGHT=10000;       //public static final int FLY_HEIGHT=10000;
    void fly();     //public abstract void fly();
}

/**
 * 善良接口
 */
interface Honest{

    void helpOthers();
}

class Angel implements Volant,Honest{

    @Override
    public void fly() {
        System.out.println("我是天使，飞呀飞！");
    }

    @Override
    public void helpOthers() {
        System.out.println("我是天使，喜欢帮助别人！");
    }
}

class BirdMan implements Volant{
    @Override
    public void fly() {
        System.out.println("我是鸟人，像鸟儿一样飞！");
    }
}

/**
 * 测试接口的多继承
 */
public class TestInterface2 implements C {

    @Override
    public void testA() {
        System.out.println("testA");
    }

    @Override
    public void testB() {
        System.out.println("testB");
    }

    @Override
    public void testC() {
        System.out.println("testC");
    }

    public static void main(String[] args) {
        C c=new TestInterface2();
        c.testA();
        c.testB();
        c.testC();
    }
}

interface A{
    void testA();
}

interface B{
    void testB();
}

interface C extends A,B{
    void testC();
}

十七、接口的新特性

/**
 * 测试接口的默认方法、静态方法、命名冲突。
 */
public class TestInterface3 {

    public static void main(String[] args) {
        TestA ta=new TestA();
        ta.moren1();
        ta.moren2();

        A1.staticMethod();      //调用接口中的静态方法，通过接口名调用

        TestA.staticMethod();   //调用实现类的静态方法，通过类名来调用

        TestB tb=new TestB();
        tb.moren1();
    }
}

interface A1{

    //定义默认方法1
    default void moren1(){
        System.out.println("A1.moren1");
    }

    //定义默认方法2
    default void moren2(){
        System.out.println("A1.moren2");
    }

    //定义静态方法
    static void staticMethod(){
        System.out.println("A1.staticMethod");
    }
}

interface B1{

    //B1接口和A1接口有相同的默认方法
    default void moren1(){
        System.out.println("B1.moren1");
    }
}

class TestA implements A1{

    //重写默认方法2
    @Override
    public void moren2() {
        System.out.println("TestA.moren2");
    }

    //实现类中定义了与接口同名的静态方法
    static void staticMethod(){
        System.out.println("TestA.staticMethod");
    }
}

//同时实现了A1和B1接口，而且接口有重名的默认方法
class TestB implements A1,B1{

    //需要重写同名的接口默认方法
    @Override
    public void moren1() {
        System.out.println("TestB.moren");
    }
}

十八、内部类

1、非静态内部类

/**
*测试非静态内部类
*/
public class Outer1 {

    private int age=18;

    public void showAge(){
        System.out.println("外部类的age是："+age);
    }

    //内部类,定义在外部类Outer1里面
    //此内部类为非静态内部类，不能有静态的属性、方法及静态初始化块
    class Inner1{

        private int id=1001;
        private int age=28;

        public void test1(){
            System.out.println("Inner1.test1");

            System.out.println("访问内部类自己的属性age:"+this.age);

            //通过：外部类名.this.属性（方法）名，来访问外部类的属性和方法
            System.out.println("访问外部类的属性age:"+Outer1.this.age);
            Outer1.this.showAge();
        }
    }
}

public class TestInnerClass1 {

    public static void main(String[] args) {

        //调用内部类
        //非静态内部类的对象，必须寄存在一个外部类对象里
        Outer1.Inner1 inner1=new Outer1().new Inner1();
        inner1.test1();
    }
}

2、静态内部类

/**
 * 测试静态内部类
 */
public class Outer2 {

    private int a=10;
    private static int b=20;

    //定义一个静态内部类
    static class Inner2{
        public void test(){
//            System.out.println(a);    //静态内部类不能访问外部类的普通属性或方法
            System.out.println(b);      //静态内部类可以访问外部类的静态属性或方法
        }
    }
}

/**
 * 测试调用静态内部类
 */
public class TestStaticInnerClass {

    public static void main(String[] args) {

        //通过new 外部类名.内部类名()来创建内部类的对象
        Outer2.Inner2 inner2=new Outer2.Inner2();
        inner2.test();
    }
}

3、匿名内部类

/***
 * 测试匿名内部类
 */
public class TestAnonymousInnerClass {

    public void run(A3 a){
        System.out.println("TestAnonymousInnerClass.run");
        a.run();
    }

    public static void main(String[] args) {
        TestAnonymousInnerClass tc =new TestAnonymousInnerClass();
        //调用匿名内部类,只使用一次
        tc.run(new A3() {
            @Override
            public void run() {
                System.out.println("匿名内部类的方法");
            }
        });

        tc.run(new A3() {
            @Override
            public void run() {
                System.out.println("A3.run");
            }
        });
    }
}

interface A3{
    void run();
}

4、局部内部类

/**
 * 测试局部内部类
 */
public class TestLocalInnerClass {

    public void show(){
        System.out.println("Step1");

        //定义一个局部内部类，作用域仅限于该方法内。
        class Inner3{

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

        //本方法中直接使用内部类
        new Inner3().run();
    }

    public static void main(String[] args) {

        TestLocalInnerClass tl=new TestLocalInnerClass();
        tl.show();
    }
}