java——面向对象（下）的学习——非常多细节

小菜日记^_^

已于 2024-01-03 10:19:37 修改

阅读量835

点赞数 22

分类专栏： Java总结文章标签： java 学习开发语言 idea

于 2023-12-26 17:08:07 首次发布

本文链接：https://blog.csdn.net/m0_57957187/article/details/135226491

版权

Java总结专栏收录该内容

22 篇文章 0 订阅

订阅专栏

下面是面向对象下半部分的学习，后面会继续对多线程、反射、io等进行学习总结，可供大家学习。本次从第九篇开始：每篇开头会解释学习的内容；

第九篇：

package java_mianxiangduixiang;
//重载：
//在java中一个类里面不能定义相同的方法和相同的属性
//这里的相同方法指的是方法名相同参数列表也相同，尽管返回值不同String int void也是相同的方法，和返回值无关；
//如果方法名相同，但是参数列表（个数、顺序、类型）不相同会认为是不同的方法，只不过名称一样，这个就叫做重载； 注：构造方法也是一样
public class java_09 {
    public static void main(String[] args) {
        User10 one=new User10();
        one.login();
        one.login("weixin");
        one.login("123","456");


        byte b=10;
        test(b);//如果byte类型的方法没有注释，则会输出bbb，如果byte类型的被注释后，会输出sss，short也被注释后，会输出iii，不会转变为ccc，先转成short然后再转成int类型；

    }
    //方法重载：
    static void test(byte bbb){
        System.out.println("bbb");
    }
    static void test(short sss){
        System.out.println("sss");
    }
    static void test(char ccc){
        System.out.println("ccc");
    }
    static void test(int iii){
        System.out.println("iii");
    }
}
class User10{

    //如果有多种登陆方法如下：
    void login(){
        System.out.println("支付宝登陆");
    }
    /*int login(){
        System.out.println("账号密码登录");
        return 0;
    }*/  //这里就算是int但是方法名和参数列表一样依然会报错；
    void login(String account,String password){
        System.out.println("账号密码登录");
    }
    void login(String wx){
        System.out.println("微信登陆");
    }

}

第十篇：

package java_mianxiangduixiang;
//TODO 方法重写：父类对象的方法其实主要体现在通用性，无法在特殊场合下使用，如果子类对象需要在特殊的场合下使用必须要重写方法，
// 这里的重写并不意味着父类方法被覆盖掉，只是在当前场合不使用，如果使用super关键字还可以调用父类方法；
//方法重写的要求：子类的方法和父类的方法方法名相同，返回值类型相同，参数列表相同
//TODO instance of方法判断对象是否属于该类
public class java_10 {
    public static void main(String[] args) {
        Childs one=new Childs();
        one.test();//会执行子类中重写的test方法；
        System.out.println(one instanceof Childs);
    }
}
class Parents{
    String name="zhangsan";
    void test(){
        System.out.println("parent");
    }
}
class Childs extends Parents{
    String name="lisi";
    void test(){//对上方父类中的test方法进行重写
        super.test();
        System.out.println("child"+" "+name);
        System.out.println(super.name);
    }
}

第十一篇：

package java_mianxiangduixiang;
//同java_10方法重写：
public class java_11 {
    public static void main(String[] args) {
        CCC c1=new CCC();
        System.out.println(c1.sum());//这个毫无疑问

        DDD d1=new DDD();
        System.out.println(d1.sum());//这个毫无疑问

        CCC c2=new DDD();
        System.out.println(c2.sum());
//这个输出40，首先需要和重载区分开，这个是重写，要记住一个对象能使用什么方法，取决于引用变量的类型，此处的类型是CCC，因此可以使用sum方法。
//一个对象的方法具体的使用是需要看具体对象的，此处的具体对象是new的DDD的，因此需要执行DDD类中重写的方法，然后方法中的属性默认的是this.i，其实是带了this的，因此是40;
//如果将DDD类中的sum方法注释掉，输出的是30，因为只能执行CCC类中的sum方法（本身多态的话就不能执行子类中特有的方法），因为没有进行重写，然后i也是父类中的，因为默认this关键字；
    }
}
class CCC{
    int i=10;
    int sum(){
        return i+=10;
    }
}
class DDD extends CCC{
    int i=20;
    int sum(){
        return i+=20;
    }
}

第十二篇：

package java_mianxiangduixiang;
//访问权限：
//java中有四种权限：
//1.private:私有权限，同一个类中可以使用；例如，当一个类中的属性用private修饰，此时在其他类中创建了一个那个类的对象，然后这个对象无法调用受private修饰的属性，此时可以在那个类中创建一个方法，这个方法可以调用这个属性；
//2.default:默认权限，当不设定任何权限时，JVM会默认提供权限，包（路径）权限，只能同一个包中使用，并且包的子包中也无法使用。
//3.protected:受保护权限：同一个包路径可以使用，并且他的子类可以访问,他的子类可能在不同包中，但是可以访问
//4.public:公开的，也就是没有限制，都可以使用

//内部类：
// 首先java中外部类不能使用private、protected修饰，只能public和default（默认）修饰；
//所谓的内部类就是在类中声明的类；内部类可以看作是外部类的属性；所以需要先创建好外部类对象才可以使用；因为需要先有外部类才能用内部类可以直接当作静态的；
public class java_12 {
    public static void main(String[] args) {
        //object类中有一个受保护的方法clone()，可知，它的子类可以去调用：
        One f=new One();
        //f.clone();此处会报错，无法调用，首先要明确java_12和one都是object的子类，本质上是可以调用的，但是你这里在java_12类中创建了一个one类的对象，这样就无法调用了，在他自己类的内部是可以调用的；
    }

    //内部类对象的创建：
    One outer=new One();
    One.InnerClass in=outer.new InnerClass();



}
class One{
    //内部类：
    class InnerClass{

    }
    void test() throws Exception{
        clone();
    }


}

第十三篇：

package java_mianxiangduixiang;
//TODO 单例模式:有时候会有两个因素：1.类的创建过程复杂。2.类的对象消耗资源；因为上述两个因素所以想只创建该类的一个对象。
public class java_13 {
    public static void main(String[] args) {
        //下方用private修饰了构造方法，因此无法大批量的创建对象；并且创建了静态的getInstance方法，可以用类直接调用，
        // 然后接着创建静态User13类的属性，然后用getInstance方法进行设置，拿到对象；
        User13 one=User13.getInstance();//这样就能拿到对象，并且每次拿到的都是一个对象，并不是创建了多个对象；
        User13 two=User13.getInstance();
        boolean b=one.equals(two);
        System.out.println(b);//true

    }
}
class User13{
    static User13 user=null;
    private User13(){//此处将构造方法私有化，因为每次new一个对象需要调用构造方法，因此在其他类中无法创建该类的对象；

    }
    public static User13 getInstance(){
        if(user==null){
            user=new User13();
        }
        return user;
    }
}

第十四篇：

package java_mianxiangduixiang;
//TODO final关键字:1.final可以修饰变量，修饰变量后变成常量，不可以更改；
// 2.final可以修饰属性，修饰属性后JVM不再初始化默认值，必须要自己赋值，并且无法更改；
// final可以修饰方法，这个方法无法被子类重写；
// final可以修饰类，这个类无法被继承；
// final不能修饰构造方法；

public class java_14 {
    public static void main(String[] args) {
        User14 user=new User14("zhangsan");
        user.test("123456");
        user.test("456789");
        System.out.println(user.tel);



    }
}
class User14{
    //以下有两种赋值方式，一种是在构造方法中赋值，一种是直接赋值；一般来说是通过构造方法进行赋值，由外面传递进来；
    final String name;
    final String username="zhangsan";
    String tel;
    //如果没有创建User14构造方法给name属性赋值的话会报错，因为JVM不再初始化默认值了；
    public User14(String name){
        this.name=name;//此处必须要加this关键字，因为形参和属性名一样，不加this的话会默认为形参给形参自己赋值；
    }
    void test(final String tel){
        //tel="123";不可以进行更改；
        this.tel=tel;

    }
}

第十五篇：

package java_mianxiangduixiang;
//TODO 抽象:java中一些类或者方法可能无法明确的定义，因此提出了抽象
// 分析问题：对象（具体）——》类（抽象）
// 编写代码：类（抽象）——》对象（具体）
//抽象类：不完整的类，就是抽象类；abstract class 类名；因为类不完整，所以无法直接构造对象；
// 注意抽象类中可以有不是抽象的方法，但是有抽象方法的类一定是抽象类；抽象类无法直接构造对象，
// 但是可以通过子类间接构建对象；如果抽象类中具有抽象方法，那么子类继承后需要重写抽象方法，
// 将方法补充完整；因此final和abstra是不能联合使用的，final修饰的方法不能被重写，但是abstract修饰的方法必须要重写，会有冲突；
//抽象方法：只有声明，没有实现的方法； abstract 返回值类型方法名（参数）；

public class java_15 {
    public static void main(String[] args) {

    }
}
abstract class Person15{
    //就像吃饭，不同国家的人吃饭的方式不同，因此无法准确的定义这个函数，此时用到abstract修饰,此时类中的方法不明确，所以类也不明确也要用abstract修饰；
    abstract void eat();
}
class China extends Person15{
    void eat(){
        System.out.println("中国人使用筷子吃饭!");
    }
}

第十六篇：

package java_mianxiangduixiang;
//TODO 接口：接口中定义的方法都是抽象方法，定义的属性都是常量不能更改；接口是不能创建对象的；
public class java_16 {
    public static void main(String[] args) {
        Computer one=new Computer();
        Light l1=new Light();
        Light l2=new Light();
        //相当于将两个小电灯插入到usb口：
        one.usb1=l1;
        one.usb2=l2;
        one.powerSupply();

    }
}
//提供了一个USB接口
interface UsbInterface{

}
//提供了一个供应电源的接口
interface USBsupply extends UsbInterface{
    public void powerSupply();
}
//提供了一个接受电源的接口
interface USBreceive extends UsbInterface{
    public void powerReceive();
}
//电脑充当电源
class Computer implements USBsupply{
    //创建了两个被供电的：
    USBreceive usb1;
    USBreceive usb2;
    public void powerSupply(){
        System.out.println("电脑提供电源");
        usb1.powerReceive();
        usb2.powerReceive();
    }
}
//电灯被供应电
class Light implements USBreceive{
    public void powerReceive(){
        System.out.println("电灯接受电源");
    }
}

第十七篇：

package java_mianxiangduixiang;
//TODO 枚举：里面寸的都是不可更改的对象；
public class java_17 {
    public static void main(String[] args) {
        System.out.println(City.BEIJING);
        System.out.println(City.BEIJING.name);

        System.out.println(Mycity.BEIJING.name);
        System.out.println(Mycity.BEIJING);

    }
}
enum City{

    BEIJING("北京","1001"),SHANGHAI("上海","1002");
    //设置了构造方法：如果写的构造函数中没有name和code参数，那么上面的对象中就不用加括号写上name和code了；
    City(String name,String code){
        this.name=name;
        this.code=code;
    }
    String name;
    String code;
}
//自己实现的简单的枚举
class Mycity{
    String name;
    String code;
    private Mycity(String name,String code){
        this.name=name;
        this.code=code;
    }
    public static final Mycity BEIJING=new Mycity("北京","1001");
    public static final Mycity SHNAGHAI=new Mycity("上海","1002");
}