Java学习

最新推荐文章于 2024-10-06 20:54:02 发布

吴佳雪的小迷妹

最新推荐文章于 2024-10-06 20:54:02 发布

阅读量861

点赞数 25

文章标签：学习

本文链接：https://blog.csdn.net/2302_81096217/article/details/136413484

版权

八面向对象编程（中级部分）

1.包

（1）包的三大作用：1）区分相同名字的类 2）当类很多时，可以很好的管理类 3）控制访问范围

（2）包的本质实际上就是创建不同的文件夹或目录来保存类文件

（3）常用的包：1) java.lang.* //lang 包是基本包，默认引入，不需要再引入. 2) java.util.* //util 包，系统提供的工具包, 工具类，使用 Scanner 3) java.net.* //网络包，网络开发 4) java.awt.* //是做 java 的界面开发，GUI

（4）注意事项：1）package 的作用是声明当前类所在的包，需要放在类(或者文件)的最上面，一个类中最多只有一句 package 2）import 指令位置放在 package 的下面，在类定义前面,可以有多句且没有顺序要求

2.访问修饰符

（1）基本介绍：1) 公开级别:用 public 修饰,对外公开

2) 受保护级别:用 protected 修饰,对子类和同一个包中的类公开

3) 默认级别:没有修饰符号,向同一个包的类公开

4) 私有级别:用 private 修饰,只有类本身可以访问,不对外公开

（2）访问范围

3.封装

（1）基本介绍：面向对象编程有三大特征：封装、继承和多态

（2）封装介绍
封装就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。
（3）封装的实现步骤(三步)
1)将属性进行私有化private【不能直接修改属性]
2) 提供一个公共的(public)set方法，用于对属性判断并赋值

public void setXxx(类型参数名){//Xxx表示某个属性
//加入数据验证的业务逻辑属性=参数名}
3) 提供一个公共的(public)get方法，用于获取属性的值
public 数据类型getXxx(){ //权限判断,Xxx 某个属性
return xx;}

public class Account {
     private String name;
     private double balance;
     private String pwd;

     //提供两个构造器
    public Account(){
    }
    public Account(String name,double balance,String pwd){
        this.setName(name);
        this.setBalance(balance);
        this.setPwd(pwd);
    }
     public void setName(String name){
         if(name.length()>=2&&name.length()<=4){
             this.name = name;
         }else{
             System.out.println("姓名要求2-4位，默认：无名");
             this.name = "无名";
         }
     }
     public String getName(){
         return name;
     }
     public void setBalance(double balance){
         if(balance>=20){
             this.balance = balance;
         }
         else{
             System.out.println("余额必须大于20 默认：0");
         }
     }
     public double getBalance(){
         return balance;
     }
     public void setPwd(String pwd){
         if(pwd.length()==6){
             this.pwd = pwd;
         }else{
             System.out.println("密码必须为6位，默认：000000");
             this.pwd = "000000";
         }
     }
     public void showTnfo(){
        System.out.println("账号信息：name="+name+" balance="+balance+" pwd="+pwd);
    }
}

public class TestAccount {
    public static void main(String[] args) {
        Account account = new Account("maliao",10,"666");
        /*account.setName("maliao");
        account.setBalance(10);
        account.setPwd("666");*/
        account.showTnfo();
    }
}

4.继承

（1）基本介绍

当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可

（2）基本语法

class 子类 extends 父类{}

（3）细节

1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问

2) 子类必须调用父类的构造器，完成父类的初始化

3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

4) 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)

5) super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)

6) super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

7) java 所有类都是 Object 类的子类, Object 是所有类的基类

8) 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)

9) 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制

（4）继承的本质

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        //要按查找关系来返回信息
        //（1）.首先看子类是否有属性
        //（2）.如果子类有这个属性，并且可以访问，则返回信息
        //（3）.如果子类没有这个属性，就看父类有没有该属性（如果父类有这个属性，并且可以访问，则返回信息）
        //（4）.如果父类没有据按照（3）的规则，继续找上级父类，直到Object
        System.out.println(son.name);
        //System.out.println(son.age);
        System.out.println(son.getAge());
        System.out.println(son.hobby);

    }
}
class Grandpa{
    String name = "大头爷爷";
    String hobby = "旅游";
    int age = 100;
}
class Father extends Grandpa{
    String name = "大头爸爸";
    private int age = 39;
    public int getAge(){
        return age;
    }
}
class Son extends Father{
    String name = "大头儿子";
}

5.super关键字

（1）基本介绍：super 代表父类的引用，用于访问父类的属性、方法、构造器

（2）super 的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用 super 去访问爷爷类的成员；如果多个基类(上级类)中都有同名的成员，使用 super 访问遵循就近原则。A->B->C

（3）super和this的比较

6.方法重写

（1）基本介绍：方法重写就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样

（2）注意事项
1）子类的方法的形参列表,方法名称,要和父类方法的形参列表,方法名称完全一样。

2）子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
3）子类方法不能缩小父类方法的访问权限 public > protected >默认>private

public class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String say(){
        return "name="+name+" age="+age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

public class Student extends Person{
    private int id;
    private double score;
    public Student(String name,int age,int id,double score){
        super(name,age);
        this.id = id;
        this.score = score;
    }
    public String say(){
        //return "name="+getName()+" age="+getAge()+" id="+id+" score="+score;
        return super.say()+" id="+id+" score="+score;
    }
    public int getId(){
        return id;
    }
    public double getScore(){
        return score;
    }
}

public class OverrideExercise {
    public static void main(String[] args) {
        Person person = new Person("maliao",4);
        Student student = new Student("jack",5,2024,99);
        System.out.println(person.say());
        System.out.println(student.say());

    }
}
/*1. 编写一个Person类，包括属性/private (name、age)，构造器、方法say(返回自我介绍的字符串).
2.编写一个Student类，继承Person类，增加id、score属性/private，以及构造
器，定义say方法(返回自我介绍的信息)。
3.在main中,分别创建Person和Student对象，调用say方法输出自我介绍。*/

7.多态

（1）基本介绍：方法或对象具有多种形态，建立在封装和继承基础之上

（2）体现：1）方法的多态：重载和重写

2）对象的多态：一个对象的编译类型和运行类型可以不一致；编译类型在定义对象时，就确定了，不能改变；运行类型可以改变；编译类型看定义时=的左边，运行类型看右边

（3）注意事项

向上转型

1) 本质: 父类的引用指向了子类的对象

2) 语法: 父类类型引用名 = new子类类型();

3) 特点: 编译类型看左边，运行类型看右边。可以调用父类中的所有成员(需遵守访问权限),不能调用子类中特有成员;

向下转型

1)语法:子类类型引用名=(子类类型)父类引用;

2) 只能强转父类的引用，不能强转父类的对象

3)要求父类的引用必须指向的是当前目标类型的对象

4)当向下转型后，可以调用子类类型中所有的成员

instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型

public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说，属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);//10
        Sub sub = new Sub();
        System.out.println(sub.count);//20

    }
}
class Base{
    int count = 10;
}
class Sub extends Base{
    int count = 20;
}

public class PolyDetail03 {
    public static void main(String[] args) {
        //instanceof 比较操作符,用于判断对象的运行类型是否为XX类型或XX类型的子类型
        BB bb = new BB();
        System.out.println(bb instanceof BB);//T
        System.out.println(bb instanceof AA);//T
        //aa 编译类型AA 运行类型BB
        
        AA aa = new BB();
        System.out.println(aa instanceof AA);//T
        System.out.println(aa instanceof BB);//T
        Object obj = new Object();
        System.out.println(obj instanceof AA);//F
        String str = "hello";
        System.out.println(str instanceof Object);//T

    }
}
class AA{}
class BB extends AA{}

（4）动态绑定机制

1.当调用对象的方法时，该方法会和对象的内存地址/运行类型绑定

2.当调用对象的属性时，没有动态绑定机制，哪里声明，那里使用