零基础自学JAVASE Part8

前言

　　这几天跑到了上海，期间又要看房又要打探一下周边的美食，导致这几天来java自学的中断。

又因为后面的内容粗略的浏览过，难度也在逐渐提高，学懂学透直至会用的时间周期可能会越来越长。

不过，怎么能被这种还没有发生的事情所吓倒呢，加油。

重点：

1. javabean 书写规范

javabean: 一个普通的类,就来描述事物的类,里面不包含任何的业务逻辑,只是用来存储数据.

　　比如: Teacher, Student, Mobile…..(作为数据的载体)

规范：

　　成员变量私有化

　　提供 get 和 set 方法( 右键->source->generate getters and setters -> select All->OK 自动生成)

　　提供无参构造方法(右键->source->generate constructor using fields-> selectAll/deSelectAll->OK 自动生成)

　　提供有参的构造方法

例子：

package com.baidu.javase05;

public class YuanGong {
    private String name; //成员变量私有化
    private int age;
    private double salary;
    
    
    public YuanGong() {} //无参构造方法
    
    //提供相应的get、set方法
    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;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    
    //自动生成和成员变量相对应的有参构造方法
    public YuanGong(String name, int age, double salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    
    
    
}

2. 同名局部变量和成员变量的调用问题

例子：

public class People {
    String name = "张三";
    public void print() {
        System.out.println(name);
    }
    
    public void print(String name) {
        System.out.println(name);
    }
    
    public void print1(String name) {
        System.out.println(this.name);
    }
    
    public static void main(String[] args) {
        People p = new People();  //首先创建实例p
        System.out.println(p.name); //因为name有初始值，打印出来的结果是“张三”
        p.name = "李四";
        p.print(); //上一步name赋值为“李四”，因此打印出来的结果是“李四”
        p.print("王五"); //打印输入的参数，打印出来的结果是“王五”
        p.print1("赵六"); //this.打印的是成员变量，打印出来的结果是“李四”
    }
}

3. static关键字

　　静态的方法中只能调用外部用 static 修饰的变量和方法,如果非要调用非静态的,需要创建对象. 原因是静态的变量或方法,最先加载到内存中,如果此时没有对象,那么成员变量还不存在,所以不能调用。

成员变量: 对象名调用　　　　对象名.成员变量　　　　p.name

静态变量: 类名调用　　　　　类名.静态变量　　　　　StaticDemo.b

例子：

public class StaticDemo {
    int a=  1;
    static int b= 2;
    
    //静态方法中只能调用static修饰的int b,调用a的话需要创建对象
    public static void main(String[] args) {
        int c; //不能print,因为局部变量不赋初始值无法使用
        System.out.println(b);
        System.out.println(StaticDemo.b); //类名调用
        
        StaticDemo demo = new StaticDemo();
        System.out.println(demo.a);
        
    }

}

4. 代码块

静态代码块： static {}

构造代码块：{}

局部代码块：定义在方法中的{} 局部代码块执行完毕后会立马释放

注：静态代码块先于构造代码块先于构造方法

例子：

public class CodeBlockDemo {
    static int count = 0;
    static {
        System.out.println("执行静态代码块");
    }
    
    {
        count++;
        System.out.println("执行构造代码块");
    }
    
    public CodeBlockDemo() {
        System.out.println("执行一次无参构造方法");
    }
    public CodeBlockDemo(int a) {
        System.out.println("执行一次有参构造方法"+ a);
    }
    public void print() {
        System.out.println("执行成员方法");
    }
    
    
    
    public static void main(String[] args) {
        CodeBlockDemo c1 = new CodeBlockDemo();
        CodeBlockDemo c2 = new CodeBlockDemo(10); //执行构造代码块+执行一次有参构造方法
        CodeBlockDemo c3 = new CodeBlockDemo(20);
        CodeBlockDemo c4 = new CodeBlockDemo();
        CodeBlockDemo c5 = new CodeBlockDemo(30);

    }

}

5. 继承

5.1 格式

　　class 子类名 extends 父类名{

　　}

5.2 注意

java 中的继承只支持单继承,不支持多继承(C++),支持多层继承

Object:(万类之祖) 如果一个类没有继承任何类,那么他默认继承自 Object

父类中的私有成员不能被继承

5.3 同一个文件中定义多个类

　　一个文件中可以定义多个类,但是必须只能有一个类使用public类, 并且用public修饰的类必须和文件名相同main 方法必须定义在用public修饰的类中(定义在非public修饰的类中无法执行)

　　同一个包中不能定义名字相同的类一个文件中定义多个类(the class already defined)

5.4 super关键字

　　super：可以看做是父类中的一个引用, 用于区分子类中和父类中同名的成员(成员变量,成员方法),super 指代的是父类中的值

　　区别this：可以看做是本类中的一个对象,用于区分同名的局部变量和成员变量,this 指代的是成员变量

应用：

　　this.成员变量　　　　super.成员变量

　　this.成员方法()　　　 super.成员方法()

调用构造方法：

　　this(参数)； ------调用本类中的构造方法

　　super()； -------调用父类中的构造方法

注意： this和super不能用于static方法中

5.5 继承中构造方法的关系

　　子类中的构造方法默认会调用父类中无参数的构造方法,如果父类中没有无参数的构

造方法,子类必须直接或间接地调用父类中其他的构造方法

public class ExtendsDemo {

    public static void main(String[] args) {
        SuperMan sm = new SuperMan();
        sm.print();
        System.out.println(sm.name);
        Man x = new Man();
        x.print();

    }

}

class SuperMan{
    String name = "超人";
    public SuperMan() {
        super();
    }
    public SuperMan(int a) {
        
    }
    public void print() {
        System.out.println("这是父类的成员方法");
    }
}

class Man extends SuperMan{
    String name = "男人";
    public Man () {
        super();
    }
    public Man (int a) {
        this(); //调用本类中的无参构造方法
    }
    public void print() {
        System.out.println("这是子类的成员方法");
    }
}

class Woman extends SuperMan{
    String name = "女人";
    public Woman () {
        super();
    }
    public Woman(int b) {
        super(1);
    }
}

5.8.方法的重载和方法的重写

概念:

　　重写(override): 子类中出现了和父类中方法名一样,返回值类型一样,参数列表一样的方法,就叫做方法的重写

　　重载(overload): 一个类中可以存在多个名字相同的方法,但是必须保证参数的个数或类型不同,与返回值无关

注解:

　　　@override 可以使用该注解验证重写格式是否正确,把它写到子类的方法上.

方法重写的注意事项:

　　1. 父类中的私有方法不能被重写(子类中可以同名的方法,只是不叫方法的重写)

　　2. 子类重写父类中的方法,访问权限不能更低

　　3. 静态的方法要想重写必须写成静态的(也不叫方法的重写)

　　　　　　(静态方法不能重写-----正确的)

（此处有个相关的练习题，我会在后续自己写好测试后补充）

6.final

　　final 可以用来修饰类,方法,变量

　　final 修饰的类不能被继承

　　final 修饰的方法不能被重写

　　final 修饰的变量值不能改变, final 修饰的变量要有初始值

一般我们创建常量:

　　public static 　　　　final

　　　　final: 限制值不能变

　　　　static: 只有一份

final 修饰的变量如果是引用数据类型,代表地址值不能变,可以修改里面的属性值;

7. 单例设计模式

class Singleton{
    private static Singleton s = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return s;
    }
}

(这个需要再研究研究，有懂的大佬讲解一下吗 0.0)

后记

　　因为几天之前是有学过这部分七七八八的了，所以再总结一遍理解的更加深刻，总感觉和上一部分有重叠的地方，

或者是我在之前复习的部分已经写过，我也实在是有点搞混了，见谅见谅

posted @ 2021-06-01 22:00 默默成功的Cason 阅读(80) 评论(2) 收藏举报

刷新页面返回顶部

默默成功的Cason

零基础自学JAVASE Part8

公告