【java学习之路】（java SE篇）005.面向对象基础入门part2

染沁半世苍凉

已于 2022-02-08 23:14:14 修改

阅读量139

点赞数

分类专栏： java学习之路文章标签： java 开发语言后端

于 2022-01-20 12:25:28 首次发布

本文链接：https://blog.csdn.net/qq_24254611/article/details/122598897

版权

java学习之路专栏收录该内容

60 篇文章 6 订阅

订阅专栏

第三章面向对象

上文链接

8.package和import

/*
* package：包，对应到文件系统就是多级目录
*   为了解决两个问题：
*       1.文件同名问题
*       2.为了方便管理类，将具体处理功能的代码放到同一个目录下
*   使用：
*       一般定义package会放置在java文件第一行
*           package 域名的倒写
*           eg：www.baidu.com --> com.baidu.xxx
* 
*   完全限定名：包名+类名
*
*	静态导包：当需要使用某个类的多个方法的时候，同时又不想频繁读写该类的名称，此时可以使用静态导包
*	import static java.lang.Math.*;
* 
*   jdk中常用的包：
*       lang：不需要手动导入，自动加载
*       util：工具包
*       net：网络包
*       io：输入输出流包
*
*	
* */

9.访问权限

/*
* 在java中明确定义了访问权限（从大到小）
*   public：公共的
*       所有的类都可以进行访问
*   protected：受保护的
*       可以被当前类访问，可以被当前包访问，可以被子类访问
*   default：默认权限
*       可以被当前类访问，可以被当前包访问
*   private：私有权限
*       可以被当前类访问
* */

10.封装※

封装：将某个功能封装成一个方法

面向对象中的封装：隐藏（不可见），将类中的某些信息不可见

/*
* 定义类的时候需要包含以下组件：
*   私有属性
*   构造方法（无参构造方法和自定义构造方法）
*   set/get方法
*   普通方法
*
* */
/*
* 封装的概念：
*   将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
*
* 封装解决什么问题？
*   如果任何一个处理类都可以对类进行赋值操作，那么当值不准确时，可能会产生不准确的结果
*   如何在赋值时添加一些逻辑判断
*
*封装的作用
*   使用封装可以保证数据的规范，不符合规范的数据将无法进行操作
*
* 封装的好处：
*   1.隐藏类的实现细节
*   2.只能通过提供的方法进行访问
*   3.可以根据需求添加复杂的逻辑判断语句
*   4.方便修改实现
* */

属性私有化

package Day01.Packaged;

public class Person {

    //private 将name属性隐藏，在其他类中无法访问
    private String name;
    private int age;

    public int getAge() {
        return age;
    }

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

    public void setName(String name){
        //方便加入控制语句
        if(name.length()>=3&&name.length()<=6){
            this.name = name;
        }
    }

    public String getName(){
        return name;
    }
}

package Day01.Packaged;

public class PersonTest {

    public static void main(String[] args) {
        Person zs = new Person();
        zs.setName("张三");
        zs.getName();
    }
}

单例模式

解决在一个程序中，只能让一个类创建一个对象

package Day01.Packaged;

public class WinsowDemo {
    /*
        将构造方法私有化，这样在其它方法中就不能创建对象了
     */
    static WinsowDemo windowDemo = null;

    private WinsowDemo(){

    }
    //向外提供一个方法，用来创建唯一一个对象，并返回此对象
    public static WinsowDemo getWindowDemo(){
        if(windowDemo == null){
            windowDemo = new WinsowDemo();
        }
        return windowDemo;
    }
}

package Day01.Packaged;

public class WindowTest {
    public static void main(String[] args) {
        System.out.println(WinsowDemo.getWindowDemo());
        System.out.println(WinsowDemo.getWindowDemo());
    }
}

11.继承※

/*
* 继承：
*   表示父类跟子类之间的关系（is-a）
*   当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承
*   使用时  extend  关键字
*   注意：java中是单继承关系
*
*   super: 是 直接父类  对象的引用
*   用途：
*       1.可以在子类中调用父类中被子类覆盖的方法  super.父类方法名称
*       2.当super在普通方法中使用时，可以任意位置编写
*       3.当super在构造方法中使用，会调用父类的构造方法，一定要把super放在第一行
*       4.在构造方法中，super（）和this（）不能同时出现
*       5.父类中的私有属性和方法都不能被调用
*       6.子类构造方法中都会默认使用super关键字调用父类的无参构造方法
*         因此在定义类的时候，无论自己是否有其他构造方法，最好将无参构造方法写上
*       7.如果构造方法中显式的指定了super构造方法，那么无参构造方法就不会被调用
*
*   总结：
*       1.在创建子类对象的时候一定会优先创造父类对象
*       2.所有的java类都具备一个老祖宗类，称之为Object
*/

package Day02.Pet;

public class Animal {

    private  String name;
    private int age;

    public void eat(){
        System.out.println(this.name+"吃东西");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

package Day02.Pet;

public class Dog extends Animal{

}

package Day02.Pet;

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.eat();
    }
}

12.重写及抽象类

/*
* 重写（@Override）：
*   必须要存在继承关系，当父类中的方法无法满足子类需求的时候可以选择使用重写的方式
*   注意：
*       1.重写表示的是子类覆盖父类地方法，当覆盖之后，调用同样的方法的时候会优先调用子类
*       2.重写的方法名称，返回值类型，参数列表必须跟父类一样
*       3.子类重写的方法不允许比父类的方法具有更小的访问权限
*
* */

/*
* java中的对象是对现实世界的具象化，但是在现实世界中，某些类并不具备实例化的意义，因此可以定义为抽象类
* 抽象类：
*   1.创建抽象类的时候，需要添加 abstract 关键字
*   2.不能进行实例化，也就是不能new对象
*   3.抽象类中的某些方法需要子类进行更丰富的实现，父类没有实现的意义，此时可以将抽象类中的方法定义为抽象方法
*     没有具体的实现，只包含方法名称，返回值，参数列表，访问修饰符
*   4.使用abstract关键字修饰的方法叫做抽象方法，可以不写方法的实现  eg：public abstract void print();
*   5.子类在继承抽象父类的时候，必须要将父类中的抽象方法进行实现或者将子类也定义为抽象类
*
* */

//Pet类
package Abstract;

public abstract class Pet {

    private String name;
    private int age;

    public abstract void print();

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

//Dog类
package Abstract;

public class Dog extends Pet{
    
    //重写抽象父类中的print方法
    @Override
    public void print() {
        System.out.println("dog.print");
    }
}

//AbstractTest类
package Abstract;

public class AbstractTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.print();
        dog.play();
    }
}

13.多态※

//父类的引用指向子类对象
        /*
            编译期间：写代码是就是编译期，Animal dog在编译期间是Animal类型
            运行期间：run运行程序，Animal dog在运行期间是Dog类型

            对于成员方法：编译看左边，运行看右边
            对于静态方法，成员变量：编译和运行都看左边

            多态的好处：提高了程序的扩展性
            多态的不足：无法调用子类中特有的方法
                解决方法：类型强制转换【有风险】
                风险解决方法：做一个判断instanceof
                if（animal instanceof Dog）{
                    Dog dog = (dog)animal;
                    dog.play;
                }

            instanceof
                测试一个对象是否为一个类的实例

         */

14.final关键字

/*
* final
*   final可以修饰变量：表示变量的值不可变
*   final可以修饰方法：表示方法不可以被重写
*   final可以修饰类：表示类不可以被继承
*/

15.接口

/*
* java中的继承关系是单继承，如果拥有多个父类的时候，可以考虑使用接口实现
*   java中的接口具备广泛的使用：
*   用法：
*       使用interface来修饰
*       接口中可以包含多个方法，且方法跟抽象类的抽象方法一致，可以不写实现，子类在实现的时候必须要实现代码逻辑
*       子类实现接口使用implements关键字
*   特征：
*       1.接口中的所有方法都是抽象方法，不能包含方法的实现
*       2.接口中的所有方法的访问权限都是public
*       3.接口不能被实例化
*       4.接口的子类必须要实现接口中的所有方法，跟抽象类有所不同，抽象类中的抽象方法才必须要被子类实现
*       5.子类可以拥有多个接口
*       6.接口中的变量都是静态常量
*       7.接口中的方法和常量无论是否添加public修饰，默认的权限只有一个public（有且仅有）
*
*   接口的使用：
*       1.接口中可以定义无数个方法，子类在进行实现的时候，必须要实现这些方法，将这些方法进行实现，就意味着具备了方法的能力
*       (接口代表了实力的一种能力，只要被定义，对应的实例就一定具备这种能力）
*
*	抽象类和接口的区别：
*		1.抽象类中的方法可以有抽象方法也可以有普通方法，但是接口中只能有抽象方法
*		2.抽象类需要使用abstract关键字修饰，而接口需要interface关键字修饰
*		3.子类使用extends关键字来继承抽象类，使用implements来实现接口
*		4.子类继承抽象类的时候必须要实现所有的抽象方法，普通方法可以不重写，而接口中的所有方法必须要重写
*		5.抽象类中可以定义成员变量，而接口中只能定义静态常量
*		6.抽象类在子类实现的时候是单继承，而接口是多继承
*		7.抽象类和接口都不能实例化，但是抽象类中可以有构造方法，而接口中不能有
* */

package Day02;

public interface MyInterface {

    int NUM = 10;   //必须赋值  public statiic final int NUM = 10;  接口中定义的属性默认是静态常量

    //public abstract void eat();
    void eat();

    void sleep();

    //java8之后新增的两种方法
    public  static  void test(){//静态方法
        System.out.println("test1"+NUM);
    }

    public default void test1(){//默认方法 让子类重写或者让子类调用的
        System.out.println("test1");
    }

}

package Day02;

public class Test {
    public static void main(String[] args) {
        System.out.println(MyInterface.NUM);

        MyInterface.test();
    }
}