Java修饰符

1、抽象概述

• 不具体的，似是而非的

• 没有具体实现的

• 好比Animal，只是对动物的大概描述

  • 能吃

  • 能睡

• 具体吃啥，怎么睡咱们无从得知，建立出来的对象意义不大

• 咱们认为这种类不该该直接建立对象，应该让其子类建立具体的对象

• 怎么限制？作成抽象类

  • abstract修饰的类能够变成抽象类

   

2、抽象类（重点）

2.1 定义

• 被abstract修饰的类成为抽象类

• 没法直接建立对象

• 抽象类中能够存在抽象方法

package com.qf.abs;
​
public class Demo01 {
 public static void main(String[] args) {
  // 抽象类没法直接建立对象
  // Animal animal = new Animal();
 }
}
​
abstract class Animal{
 
 public abstract void eat();
 
}
​

2.2 抽象类的子类和对象

• 抽象类没法直接建立对象，可是能够有子类

• 抽象类的子类继承抽象类以后能够获取到抽象类中的非私有普通属性和方法

• 抽象类的子类若是想使用抽象类中的抽象方法，必须重写这些方法以后才能使用

• 若是不使用抽象方法，作成抽象类也是能够的

package com.qf.abs;
​
public class Demo01 {
 public static void main(String[] args) {
  // 抽象类没法直接建立对象
  // Animal animal = new Animal();
  Husky husky = new Husky();
  System.out.println(husky.type);
  husky.breath();
  husky.eat();
 
 }
}
​
/**
 * 抽象类Animal
 *  描述动物的一个类
 *  只作了大概的描述，没有具体的实现
 *  须要子类继承此类后作具体的描述
 * @author Dushine2008
 *
 */
abstract class Animal{
 
 // 属性
 String type = "动物";
 String section;
 
 public abstract void eat();
 
 public abstract void sleep();
 
 public void breath() {
  System.out.println("全部的动物都依赖氧气存活...");
 }
 
}
​
​
abstract class Dog extends Animal{
 
}
​
class Husky extends Dog{
​
 @Override
 public void eat() {
  System.out.println("二哈喜欢和主人同吃同住...");
 }
​
 @Override
 public void sleep() {
  System.out.println("二哈和主人同住同吃.................");
 }
 
}

3、抽象类和多态案例（掌握）

• 建立抽象类Car

• 建立Car的子类

  • Auto

  • Bus

  • Tractor

• 在子类重写继承的抽象方法和本身独有的方法

• 使用多态的思想建立对象并调用这些方法

package com.qf.abs;
​
public class Demo02 {
 public static void main(String[] args) {
  Car car01 = new Auto();
  car01.start();
  car01.stop();
  
  // 向下转型
  Auto auto = (Auto) car01;
  auto.manned();
  
  System.out.println("========================");
  
  Car car02 = new Bus();
  car02.start();
  car02.stop();
  
  // 拆箱
  Bus bus = (Bus) car02;
  bus.manned();
 
  System.out.println("========================");
  
  Car car03 = new Tractor();
  car03.start();
  car03.stop();
  
  Tractor tractor = (Tractor) car03;
  tractor.doFarmWork();
  
 }
}
​
/**
 * 车的顶层类
 *  抽象类
 *  方法没有具体的实现
 * @author Dushine2008
 *
 */
abstract class Car{
 // 属性
 int weight;
 int height;
 String brand;
 int price;
 
 // 方法
 public abstract void start();
 
 public abstract void stop();
}
​
/**
 * 奥拓车
 *  继承Car
 *  重写启动和中止的方法
 * @author Dushine2008
 *
 */
class Auto extends Car{
​
 @Override
 public void start() {
  System.out.println("Auto拧钥匙启动...");
 }
​
 @Override
 public void stop() {
  System.out.println("Auto这个车子刹车系统是鼓刹...");
 }
 
 public void manned() {
  System.out.println("Auto这辆小车能载人5个...");
 }
 
}
​
/**
 * Bus类
 *  继承了Car类
 *  重写抽象方法
 * @author Dushine2008
 *
 */
class Bus extends Car{
​
 @Override
 public void start() {
  System.out.println("Bus启动方式不少，能够拧钥匙，能够人力推，还可以使用摇把启动...");
 }
​
 @Override
 public void stop() {
  System.out.println("Bus刹车使用脚刹...");
 }
 
 public void manned() {
  System.out.println("Bus载人数量能达到百人");
 }
 
}
/**
 * Tractor类
 *  继承了Car类
 *  重写抽象方法
 * @author Dushine2008
 *
 */
class Tractor extends Car{
​
 @Override
 public void start() {
  System.out.println("Tractor早期使用摇把，后来升级了电启动...");
 }
​
 @Override
 public void stop() {
  System.out.println("Tractor手扶拖拉机使用手刹,很拉风...");
 }
 
 public void doFarmWork() {
  System.out.println("Tractor能够在农场里干活...");
 }
 
}

4、static（重点）

4.1 定义

• static是java中的关键字

• 能修饰变量、方法、内部类

5、 静态变量（掌握）

• 被static修饰的变量成为静态变量--类变量--整个类中只存在一份

• 静态变量被全部此类建立的对象共享，在内存中只存在一份

• 在任意位置修改了这个变量，后面的对象获取到的就是修改以后的结果

• 推荐使用类名.属性名调用

4.2.1 非静态变量的建立和使用

package com.qf.static0;
​
public class Demo01 {
 public static void main(String[] args) {
  MyClass c01 = new MyClass();
  c01.str = "我是c01中的变量str";
  System.out.println(c01.str);
  System.out.println(c01);
  
  MyClass c02 = new MyClass();
  c02.str = "我是c02中的变量str";
  System.out.println(c02.str);
  System.out.println(c02);
  
 }
}
​
​
class MyClass{
 // 属性--实例变量--成员变量
 String str;
}
​

4.2.2 静态变量的建立和使用

package com.qf.static0;
​
public class Demo02 {
 public static void main(String[] args) {
  MyClass c01 = new MyClass();
  c01.str = "我是c01中的变量str";
  System.out.println(c01.str);
  System.out.println(c01);
  
  MyClass c02 = new MyClass();
  c02.str = "我是c02中的变量str";
  System.out.println(c02.str);
  System.out.println(c02);
  
  YourClass y01 = new YourClass();
  YourClass.capital = "我是韩国的国都汉城";
  System.out.println(YourClass.capital);
  System.out.println(y01);
  
  YourClass y02 = new YourClass();
  YourClass.capital = "我是韩国的国都首尔";
  System.out.println(y01.capital);
  System.out.println(y02);
  
 }
}
​
class YourClass{
 // 被static修饰的变量成为静态变量--类变量--整个类中只存在一份，被全部此类建立的对象共享，在内存中只存在一份
 static String capital;
}

4.2.3 内存图

 

 

4.2.4 记录对象建立次数

package com.qf.static0;
​
public class Demo03 {
 public static void main(String[] args) {
  System.out.println(OurClass.count);
  
  OurClass oc1 = new OurClass();
  System.out.println(OurClass.count);
  
  OurClass oc2 = new OurClass();
  System.out.println(OurClass.count);
  
  OurClass oc3 = new OurClass();
  System.out.println(OurClass.count);
  
  OurClass oc4 = new OurClass();
  System.out.println(OurClass.count);
 }
}
​
class OurClass{
 // 定义静态的变量count，记录被执行次数
 static int count = 0;
 
 public OurClass(){
  // 构造方法每一次调用都自增一下
  count++;
 }
}
​
class User{
 
}

6、静态方法（掌握）

6.1 定义

• static修饰的方法成为静态方法

• 不用建立对象就能直接调用

package com.qf.static0;
​
public class Demo04 {
 public static void main(String[] args) {
  // System.out.println(Integer.MIN_VALUE);
  // 调用静态属性
  System.out.println(MathUtil.PI);
  System.out.println(MathUtil.maxInteger);
  System.out.println(MathUtil.minInteger);
  
  // 调用静态方法
  double abs = MathUtil.getAbs(-23.45);
  System.out.println(abs);
  
  double pow = MathUtil.getPow(3, 0);
  System.out.println(pow);
  
 }
}
​
class MathUtil{
 
 // 属性
 static double PI = 3.141592653589793;
 static int maxInteger = 2147483647;
 static int minInteger = -2147483648;
 
 // 方法
 /**
 * 获取绝对值
 * @param d
 * @return
 */
 public static double getAbs(double d) {
  return d >= 0 ? d : -d; 
 }
 
 /**
 * 计算a的b次方的结果
 * @param a
 * @param b
 * @return
 */
 public static double getPow(double a,int b) {
  int result = 1;
  for (int i = 0; i < b; i++) {
   result *= a;
  }
  return result;
 }
 
}
​

6.2 静态方法调用其余属性和方法

• 静态方法调用静态属性

  • 能够

• 静态方法调用静态方法

  • 能够

• 静态方法调用非静态属性

  • 不能够

• 静态方法调用非静态方法

  • 不能够

package com.qf.static0;
​
public class Demo05 {
 public static void main(String[] args) {
  
 }
}
​
​
class Stu{
 // 实例属性,对象建立的时候加载到堆内存
 String name = "张三";
 // 静态属性,类属性,随着类的加载,加载的时间早于实例属性
 static int age = 23;
 
 // 实例方法,建立对象的时候加载进内存,加载的时间比静态的晚
 public String getInfo() {
  // 能够在非静态方法中调用静态方法和静态变量
  show();
  return name + "===" + age;
 }
 
 // 静态方法,随着类的加载而加载,加载时间早于实例属性,没法在此调用实例属性
 public static void show() {
  System.out.println(age);
  // 在静态方法中只能调用静态变量和静态方法
  // getInfo();
  // System.out.println(name);
 } 
}

6.3 静态方法、属性的继承

• 子类能够获取到父类中的实例属性、方法

• 子类能够获取到父类中的静态属性、方法

• 子类能够重写父类中的实例方法

• 子类不能重写父类的静态方法

package com.qf.static0;
​
public class Demo06 {
 public static void main(String[] args) {
  Man man = new Man();
  man.show();
  String info = man.getInfo();
  System.out.println(info);
  
  Human.type = "壮实的";
  man.show();
  
  man.type = "力气大的";
  System.out.println(Human.type);
  
 }
}
​
/**
 * 类Human
 *  人类
 *  有各类各样的属性和方法
 * @author Dushine2008
 *
 */
class Human{
 // 实例属性
 String name = "李四";
 
 // 静态属性,能够被继承
 static String type = "好看的";
 
 // 实例方法
 public void show() {
  System.out.println("我是" + name + ",我喜欢的类型是:" + type);
 }
 
 // 静态方法,子类能够调用,可是不能重写/覆盖
 public static String getInfo() {
  return "张三喜欢的类型:===" + type;
 }
}
​
class Man extends Human{
 @Override
 public void show() {
  System.out.println(name + ",我不单单喜欢===" + type);
 }
 
 /*@Override
 public static String getInfo() {
  return "张三喜欢的类型不单单是:===" + type;
 }*/
}
​

7、代码块

7.1 局部代码块（熟练）

7.1.1 定义

• 定义在方法中的代码块成为局部代码块

• 随着所在方法的调用而执行

• 能够调用所在方法和类中的变量

• 代码块内部也能够定义变量，外部访问不到

• 适合临时用一下的一些数据的处理

7.1.2 案例

package com.qf.block;
​
public class Demo01 {
 static  int  num = 33;
 public static void main(String[] args) {
  int a = 110;
  
  System.out.println("HelloWorld01");
  System.out.println("HelloWorld02");
  
  {
   // 局部代码块
   // 无痕浏览
   int b = 220;
   System.out.println("我是main方法中的局部代码块" + num);
  }
  
  System.out.println("HelloWorld03");
  System.out.println("HelloWorld04");
  System.out.println("HelloWorld05");
  
 }
}

 

7.2 动态代码块(构造代码块)（掌握）

7.2.1 定义

• 定义在类中的代码块，位置和构造方法、实例变量同一级

• 每一次建立对象的时候被调用

• 能够完成构造方法中相同或者类似的代码,对构造方法进行初始化

7.2.2 案例

package com.qf.block;
​
public class Demo02 {
 public static void main(String[] args) {
  
  Restaurant restaurant1 = new Restaurant();
  //Restaurant restaurant2 = new Restaurant("");
  //Restaurant restaurant3 = new Restaurant("","");
  
 }
}
​
class Restaurant{
 
 String name;
 String addr;
 
 {
  // 随着对象的建立执行,每建立一个对象就执行一次,能够把构造方法中相同的部分写在此处,在此完成构造方法的初始化
  // 加载时间早于构造方法,加载时间和实例属性部分前后,谁在前谁先上
  System.out.println("几位爷里面请!!!");
  System.out.println(name + "==" + addr);
 }
 
 public Restaurant() {
  super();
  System.out.println("空参构造方法。。。");
 }
 
 public Restaurant(String addr) {
  super();
  this.addr = addr;
  System.out.println("1参构造方法。。。");
 }
​
 public Restaurant(String name, String addr) {
  super();
  this.name = name;
  this.addr = addr;
  System.out.println("2参构造方法。。。");
 }
 
}

 

7.3 静态代码块（掌握）

7.3.1 定义

• 使用static修饰的代码块，定义在类中方法外，和变量、动态代码块的位置同样

• 类第一次加载的时候调用，整个程序周期中只执行一次

• 能够用来加载驱动等只执行一次的操做

7.3.2 案例

package com.qf.block;
​
public class Demo03 {
 public static void main(String[] args) {
  System.out.println("开始建立对象");
  Mouse mouse1 = new Mouse();
  Mouse mouse2 = new Mouse();
  Mouse mouse3 = new Mouse();
  Mouse mouse4 = new Mouse();
 }
}
​
class Mouse{
 // 属性
 String brand;
 String color;
 
 {
  System.out.println("我是动态代码块...");
 }
 
 static {
  System.out.println("我是静态代码块================");
 }
 
 // 构造方法
 public Mouse() {
  super();
 }
​
 public Mouse(String brand) {
  super();
  this.brand = brand;
 }
​
 public Mouse(String brand, String color) {
  super();
  this.brand = brand;
  this.color = color;
 }
}

7.4 同步代码块（了解）

• 多线程中会讲解