尚硅谷Java基础笔记 | Day14

该笔记基于B站视频：尚硅谷Java入门视频教程

 

 今日学习：面向对象-下：

面向对象下主要学习内容：
        1，关键字：static

        2，理解main方法的语法

        3，类的成员之四：代码块

        4，关键词：final

        5，抽象类与抽象方法

        6，接口(interface)

        7，类的成员之五：内部类    

今日学习前1,2,3,4部分。 

     

目录

 1，关键字：static 

    static关键字的使用：

        1.1：static修饰属性时：称为静态变量（类变量）

2， 理解main方法的语法

3，类的成员之四：代码块（初始化块）

4，final关键字

---

 1，关键字：static 

        前提引入：当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上 的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象， 其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少 对象的情况下，某些特定的数据在内存空间里只有一份

        例如：所有的中国人都有个 国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中 都单独分配一个用于代表国家名称的变量。

    static关键字的使用：

        1.static:静态的 

        2.static可以用来修饰：属性、方法、代码块、内部类

        1.1：static修饰属性时：称为静态变量（类变量）

        属性：

                按是否使用static修饰，又分为：静态属性和非静态属性（实例变量）

                实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

                静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。 

        引入代码如下：

package Day14.Static;

public class StaticTest {
    public static void main(String[] args) {
        Chinese c1=new Chinese();
        c1.name="姚明";
        c1.age=40;

        Chinese c2=new Chinese();
        c2.name="马龙";
        c2.age=30;

        c1.nation="CHN";
        System.out.println(c2.nation);
        c1.eat();//非静态方法
        Chinese.show();//静态方法
    }
}
class Chinese{
    String name;
    int age;
    static String nation;//静态变量
    public void eat(){
        System.out.println("中国人吃中餐");
        show();//可以调用
    }
    public static void show(){
        System.out.println("我是中国人");
//        eat();不能够调用
//        name="tom";
//        可以调用的结构
        System.out.println(Chinese.nation);
        walk();
    }
    public static void walk(){
        System.out.println("走路");
    }
}

 

 

        在上图中c1、c2各占一部分空间，当对c1、c2单独做修改时互不影响，而通过某一个变量对nation进行修改时，会导致另一个变量的静态变量也被修改，主要是因为静态变量是被共享的。

         举现实例子来讲：在住共享公寓时，你的房间内的东西和你室友房间的东西分别为实例变量，而你们公用的厕所或者厨房为静态变量

     

 1.1.2 static修饰属性的其他说明：
          ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用

          ② 静态变量的加载要早于对象的创建。

          ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

          ④        类变量    实例变量
          类        yes        no

          对象    yes        yes

          即不能通过类调用实例变量，但是可以通过类调用类变量。

          静态属性举例：System.out;Math.PI。

1.2 static修饰方法的说明：静态方法、类方法

        ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
        ②                      静态方法    非静态方法
           类                    yes           no
           对象                yes             yes
        ③ 静态方法中，只能调用静态的方法或属性
            非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

 

1.3 static的注意点：
         在静态的方法内，不能使用this关键字、super关键字、非静态的结构，可以调用静态的结构。而非静态的方法可以直接调用静态的结构。

         静态对象是随着类的产生而产生，随着类的消失而消失的。

 1.4 何时使用static声明    

        1.4.1 关于属性
        > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。

        > 类中的常量也常常声明为static

        1.4.2 关于方法
        > 操作静态属性的方法，通常设置为static的

        > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

1.5 应用举例：

        Circle型：当创建圆的数量增加时，id和total随创建数量的增加而增加

package Day14.Static;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle();
        Circle c3 = new Circle();
        System.out.println("c1:" + c1.getId());
        System.out.println("c2:" + c2.getId());
        System.out.println("c2:" + c3.getId());
        System.out.println("创建圆的个数为：" + Circle.getTotal());
    }
}

class Circle {
    private double radius;
    private int id;
    public Circle() {
        id = init++;//递进式增加id，因为init是静态的
        total++;
    }

    public Circle(double radius) {
        this();//进行无参Circle()
        this.radius = radius;
    }

    private static int total;//创建的圆的个数
    private static int init = 1001;//static声明的属性被所有的对象共享
    public double findArea() {
        return 3.14 * radius * radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public int getId() {
        return id;
    }

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

    public static int getTotal() {
        return total;
    }

    public static int getInit() {
        return init;
    }

    public static void setInit(int init) {
        Circle.init = init;
    }
}

1.5 static小型练习

      

1.5.1  练习1 ：编写一个类实现银行账户的概念，包含的属性有“帐号”、“密 码”、“存款余额”、“利率”、“最小余额”，定义封装这些 属性的方法。账号要自动生成。 编写主类，使用银行账户类，输入、输出3个储户的上述信息。 考虑：哪些属性可以设计成static属性。

package Day14.Static;
//练习1
//编写一个类实现银行账户的概念，包含的属性有“帐号”、“密
//码”、“存款余额”、“利率”、“最小余额”，定义封装这些
//属性的方法。账号要自动生成。
//编写主类，使用银行账户类，输入、输出3个储户的上述信息。
//考虑：哪些属性可以设计成static属性。
public class Account {
    private int id;
    private String pwd="000000";
    private double balance;

    private static double interestRate;//利率
    private static double minMoney=1.0;//最低金额
    private static int init=1001;//用于自动生成id

    public Account(){
        id=init++;
    }
    public Account(String pwd,double balance){
        this();
        this.pwd=pwd;
        this.balance=balance;
    }

    public int getId() {
        return id;
    }

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

    public String getPwd() {
        return pwd;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public static double getInterestRate() {
        return interestRate;
    }

    public static void setInterestRate(double interestRate) {
        Account.interestRate = interestRate;
    }

    public static double getMinMoney() {
        return minMoney;
    }

    public static void setMinMoney(double minMoney) {
        Account.minMoney = minMoney;
    }

    public static int getInit() {
        return init;
    }

    public static void setInit(int init) {
        Account.init = init;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", pwd='" + pwd + '\'' +
                ", balance=" + balance +
                '}';
    }
}


package Day14.Static;

public class AccountTest {
    public static void main(String[] args) {
        Account acct1=new Account();
        Account acct2=new Account("qwerty",2000);
        Account.setInterestRate(0.02);
        Account.setMinMoney(100);
        System.out.println(acct1);
        System.out.println(acct2);
        System.out.println(Account.getInterestRate());
        System.out.println(Account.getMinMoney());

    }
}

    1.5.2 单例（Singleton）设计模式

        ·设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典 的棋谱，不同的棋局，我们用不同的棋谱。”套路”

         ·所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对 某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构 造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生 类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无 法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的。

         1.5.2.1 饿汉式：在一开始就new好对象

package Day14.Static;
//单例设计模式
//所谓类的单例设计模式就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一种对象实例
//饿汉式单例设计模式
public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank1=Bank.getInstance();
        Bank bank2=Bank.getInstance();
        System.out.println(bank1==bank2);//true
    }
}
class Bank{
    //1,私有化的构造器
    private Bank(){

    }
    //2.内部创建类的对象
    //4.要求此对象必须声明为静态的
    private static  Bank instance =new Bank();
    //3.提供公共的方法，返回类的对象
    public static  Bank getInstance(){
        return instance;
    }
}

   1.5.2.2 懒汉式：什么时候用什么时候造

 

package Day14.Static;
//懒汉式实现:什么时候用什么时候造
public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1=Order.getInstance();
        Order order2=Order.getInstance();
        System.out.println(order1==order2);
    }
}
class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类的对象，没有初始化
    private static Order instance=null;
    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if (instance == null) {
            instance=new Order();
        }
        return instance;
    }
}

       1.5.2.3 饿汉式和懒汉式的区别：

                饿汉式：坏处：对象的加载时间过长

                               好处：是线程安全的

                懒汉式：好处：延迟对象的创建

                               坏处：目前来说线程不安全

        1.5.2.4 单例模式的优点：

                由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的 产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可 以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方 式来解决。

        1.5.2.5 单例模式的应用场景：

• 网站的计数器，一般也是单例模式实现，否则难以同步。
• 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志 文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库 资源。
• 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置 文件数据，都生成一个对象去读取。
• Application 也是单例的典型应用
• Windows的Task Manager (任务管理器)就是很典型的单例模式
• Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程 中，回收站一直维护着仅有的一个实例。

---

2， 理解main方法的语法

• 由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是 public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须 是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令 时传递给所运行的类的参数。
• 又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创 建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

2.1 main方法的使用说明

1. main()方法作为程序的入口
2. main()方法也是一个普通的静态方法
3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

        2.2 main方法数组：

            2.2.1 在idea中：

                        

package Day14.Main;

public class MainDemo {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("========="+args[i]);
            int num=Integer.parseInt(args[i]);
            System.out.println("---------"+num);
        }
    }
}

              main方法 传参进入数组方法：

1.  打开运行                  
2.  打开编辑配置 
   
3. 进行修改

 

---

 3，类的成员之四：代码块（初始化块）

                

         3.1 代码块的作用：用来初始化类、对象的信息

        

          3.2 代码块要使用的修饰符只能使用static

          3.3 分类：静态代码块和非静态代码块

package Day14.Block;

public class BlockTest {
    public static void main(String[] args) {
        String desc =Person.desc;//静态
        System.out.println(desc);
        System.out.println("======================");
        Person p1=new Person();//非静态
        Person p2=new Person();
        System.out.println(p1.age);
        Person.info();
    }
}

class Person {
    //属性
    String name;
    int age;
    static String desc = "我是一个人";

    //构造器
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //代码块
    static {
        System.out.println("Hello Static Block2");
    }
    static {
        System.out.println("Hello Static Block1");
        desc="Static desc change";
    }
    {
        System.out.println("Hello Block2");
    }
    {
        System.out.println("Hello Block1");
        age=1;
    }
    //方法
    public void eat() {
        System.out.println("吃饭");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public static void info(){
        System.out.println(".......");
    }
}

     静态代码块：

•           内部可以输出语句
•           随着类的加载而执行,而且只执行一次
•           作用：初始化类的信息
•           如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
•           静态代码块的执行要优先于非静态代码块的执行
•           静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
•  

 

      非静态代码块： 

•         内部可以输出语句
•         随着对象的创建而执行
•         每创建一个对象，就执行一次非静态代码块
•         作用：可以在创建对象时，对对象的属性等进行初始化
•         如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
•         非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
• 

 3.4 代码块举例

package Day14.Block;
class Root{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root(){
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid(){
		System.out.println("Mid的无参数的构造器");
	}
	public Mid(String msg){
		//通过this调用同一类中重载的构造器
		this();
		System.out.println("Mid的带参数构造器，其参数值："
			+ msg);
	}
}
class Leaf extends Mid{
	static{
		System.out.println("Leaf的静态初始化块");
	}
	{
		System.out.println("Leaf的普通初始化块");
	}	
	public Leaf(){
		//通过super调用父类中有一个字符串参数的构造器
		super("尚硅谷");
		System.out.println("Leaf的构造器");
	}
}
public class LeafTest{
	public static void main(String[] args){
		new Leaf(); 
		//new Leaf();
	}
}

        总结：由父及子，静态先行

属性的赋值顺序：

•  ①默认初始化
•  ②显式初始化   /   ⑤在代码块中赋值
•  ③构造器中初始化
•  ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值

 执行的先后顺序：① - ② / ⑤ - ③ - ④

 

---

4，final关键字

• 1,在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
   
• 2,final标记的类不能被继承。提高安全性，提高程序的可读性。 比如String类、System类、StringBuffer类
   
• 3,final标记的方法不能被子类重写。 比如：Object类中的getClass()（获取当前对象所属的类）。
   
• 4,final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。   
           
     final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化
  
     final修饰局部变量：尤其是使用final修饰形参时，表明该形参是一个常量。当我们调用此方法时，给常量形参赋一个实参，一旦以后，就只能在方法体中使用此形参，但不能进行重新赋值。
  
     static final：用来修饰属性：全局常量。
• 5,final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。
   
• 6,final double MY_PI = 3.14;