08-04

package com.atguigu.exer;

import java.awt.Label;

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;

  public Account() {

     id = init++;

  }

  public Account(String pwd, double balance) {

     id = init++;

     this.pwd = pwd;

     this.balance = balance;

  }

  public String getPwd() {

     return pwd;

  }

  public void setPwd(String pwd) {

     this.pwd = pwd;

  }

  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 int getId() {

     return id;

  }

  public double getBalance() {

     return balance;

  }

  @Override

  public String toString() {

     return "Account [id=" + id + ", pwd=" + pwd + ", balance=" + balance + "]";

  }

}

package com.atguigu.exer;

public class AcconutTest {

  public static void main(String[] args) {

     Account acct1 = new Account();

     Account acct2 = new Account("123456", 2323);

     Account.setInterestRate(0.001);

     Account.setMinMoney(50000);

     System.out.println(acct1);

     System.out.println(acct2);

    System.out.println(acct1.getInterestRate());

     System.out.println(acct1.getMinMoney());

  }

}

package com.atgyugu.java;

public class CircleTest {

  public static void main(String[] args) {

     Circle c1 = new Circle();

     Circle c2 = new Circle();

     System.out.println(c1.getId());

     System.out.println(c2.getId());

     System.out.println(Circle.getTotal());

  }

}

class Circle {

  private double radius;

  private int id;

  public Circle() {

     id = init++;

     total++;

  }

  public Circle(double radius) {

     this();

     this.radius = radius;

  }

  private static int total;

  private static int init = 1001;

  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 static int getTotal() {

     return total;

  }

}

package com.atgyugu.java;

/*

 * static关键字的属性

 *

 * 1、static ：静态的

 *

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

 *

 * 3、使用static修饰属性：静态变量

 *     3-1属性，按是否使用static修饰，又分为：静态属性 vs 动态属性

 *        实例属性：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性

 *        当修改其中一个对象中的非静态属性，不会导致其他对象中的同样属性值的修改

 *

 *        静态变量：我们创建了类的多个变量，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，

 *        会导致其他对象调用次变量，是修改过的

 *  

 *     3-2静态变量可以通过类来调用，实例属性必须通过对象调用，使用对象的存储

 *    

 *  

 * 4、使用static修饰方法：静态方法

 *     ①随着类的加载而加载，可以通过“类.静态方法”的方式进行调用

 *     ②    静态方法    非静态方法

 *        类   y      n

 *        对象   y      y

 *

 *     ③静态方法中，只能调用静态的方法或属性

 *     非静态的方法中，即可以调用非静态的方法或属性，也可以调用静态的方法和属性

 *

 * 5、static注意点：

 *     5.1在静态的方法内，不能使用this关键字、super关键字

 *     5.2关于静态属性和静态方法的使用，从声明周期理解

 *

 * 6.开发中如何让确定一个属性要声明为static

 *     属性

 *     属性可以被多个对象所共享的，不会随着对象的不同而不同的

 *     方法

 *     操作静态属性的方法，通常设置为static的

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

 *

 */

public class StaticTest {

  public static void main(String[] args) {

     Chinses.nation = "中国";

     Chinses c1 = new Chinses();

     Chinses.show();

  }

}

class Chinses {

  String name;

  int age;

  static String nation;

  public void eat() {

     System.out.println("中国人吃中餐");

  }

  public static void show() {

     System.out.println("我是一个中国人");

  }

}

package com.atgyugu.java2;

/*

 * 饿汉式vs懒汉式

 * 饿汉式 坏处：对象加载时间长。好处：线程安全

 *

 * 懒汉式 坏处：不安全   好处：延迟对象的创建

 *

 *

 *

 */

public class SingletonTest1 {

  public static void main(String[] args) {

     Bank bank1 = Bank.getInstsnce();

     Bank bank2 = Bank.getInstsnce();

  }

}

//饿汉式

class Bank {

  private Bank() {

  }

  private static Bank instance = new Bank();

  public static Bank getInstsnce() {

     return instance;

  }

}

package com.atgyugu.java2;

public class SingletonTest2 {

  public static void main(String[] args) {

     Bank bank1 = Bank.getInstsnce();

     System.out.println(Bank.getInstsnce());

  }

}

//懒汉式

class Order {

  private Order() {

  }

  private static Order instance = null;

  public static Order getInstance() {

     if (instance == null) {

       instance = new Order();

     }

     return instance;

  }

}

package com.atgyugu.java3;

/*类的成员之四：代码块

 *

 * 1、代码块的作用：用来初始化类、对象

 * 2、代码块如果有修饰的话，只能用static

 * 3、分类：静态代码块 vs 非静态代码块

 * 

 * 4、静态代码块

 *   >内部可以有输出语句

 *   >随着类的加载而加载,而且只执行一次

 *   >内部可以有输出语句

 *  >随着类的加载而执行优先于非静态代码块执行

 *  >静态代码块只能调用静态的属性、静态的方法、不能 调用非静态的结构

 * 

 *

 * 5、非静态代码块

 *     >内部可以有输出语句

 *     >随着对象的创建而执行

 *     >每创建一个对象，就执行一次非静态代码块

 *     >作用：可以在创建对象时，对对象的属性初始化

 *     >如果一个类中定义了多个非静态代码块，则按照声明顺序的先后执行

 *     >非静态代码块可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

 *

 *

 * 5、对属性可以赋值的位置：

 * ①默认初始化

 * ②显示初始化

 * ③构造器初始化

 * ④有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值

 * ⑤在代码块中赋值

 *

 */

public class BlockTest {

  public static void main(String[] args) {

     String desc = Person.desc;

     Person p1 = new Person();

  }

}

class Person {

  // 属性

  String name;

  int age;

  static String desc = "我是一个人";

  // 构造器

  public Person() {

  }

  public Person(String name, int age) {

     this.name = name;

     this.age = age;

  }

  // 代码块

  {

     System.out.println("hello");

  }

  static {

     System.out.println("hello,static");

  }

  // 方法

  public void eat() {

     System.out.println("吃饭");

  }

  @Override

  public String toString() {

    

package com.atgyugu.java3;

/*

 * final:最终的

 *

 * 1.final可以用来修饰的结构：类、方法、变量

 *

 * 2.final 用来修饰一个类:此类不能被其他类继承

 *

 * 3.final 用来修饰方法：表明此方法不可以被重写

 *

 * 4.final 用来修饰一个变量：此时的就成为常量

 *     final修饰属性：可以赋值的位置：显式初始化，代码块中初始化、构造器中初始化

 *

 *

 *

 *

 */

public class FinalTest {

}

final class Final{

 

}