Java语言基础(14) - HelloWorld开发者社区

1 访问控制修饰符(二)

　　1）public：公共的，可以用来修饰类，属性，构造方法以及方法，被public修饰的类，属性，构造方法以及方法，可以任意的进行访问。
　　2）private：私有的，可以用来修饰属性，构造方法以及方法，被private修饰的属性，构造方法以及方法，只能在本类的内部访问，外界无法访问。
　　3）一般针对private修饰的私有属性，都建议编写使用public修饰的get()/set()方法进行访问。
　　　　get()方法：获得属性的值。
　　　　set()方法：设置属性的值。
　　　　案例：Demo1

public class Demo1 {
  public static void main(String[] args) {
    Foo1 foo = new Foo1("韩信",36);
    int age = foo.getAge();
    System.out.println(age);
    String name = foo.getName();
    System.out.println(name);
    foo.setName("刘邦");
    String name2 = foo.getName();
    System.out.println(name2);
    foo.setAge(46);
    int age2 = foo.getAge();
    System.out.println(age2);
  }
}
class Foo1{
//属性
  private String name;
  private int age;
//构造方法
  public Foo1(String name,int age){
    this.name = name;
    this.age = age;
  }      
//方法
  public int getAge(){
    return age;  
  }
  public void setAge(int age){
    this.age = age;
  }
  public String getName(){
    return name;  
  }
  public void setName(String name){
    this.name = name;  
  }
}

public class Demo2 {

}

class User {
    // 属性（private）：姓名，年龄，职位，工资，地址，
    // 邮箱，婚否(boolean marry)
    private String name;
    private int age;
    private String job;
    private double salary;
    private String address;
    private String email;
    private boolean marry;

    // 构造方法：给每一个属性赋值
    public User(String name, int age, String job, double salary,
            String address, String email, boolean marry) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.salary = salary;
        this.address = address;
        this.email = email;
        this.marry = marry;
    }

    // 方法：给每一个私有属性提供对应的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 String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
//boolean类型私有属性，get方法是以is开头
    public boolean isMarry() {
        return marry;
    }

    public void setMarry(boolean marry) {
        this.marry = marry;
    }

}

　　4）默认的：系统默认提供访问控制修饰符，可以用来修饰类，属性，构造方法以及方法，被默认修饰类，属性，构造方法以及方法，在本包内任意访问，不同包之间无法访问。
　　5）不同包之间创建对象，必须要先导入该对象所属的类
　　　　import 包名.类名;
　　　　案例：Demo3

import com.tarena.demo2.Person;
//import 包名.类名;
public class Demo3 {
  public static void main(String[] args) {
    Person p1 = new Person();
    System.out.println(p1.name);
//被public修饰的属性，外界可以任意的访问。
//    System.out.println(p1.age);
//被private修饰的属性，只能在本类的内部访问，外界
//无法访问。
//    System.out.println(p1.address);
//被默认修饰的属性，只能在本包内访问，不同包之间无法
//访问。    
  }
}

2 抽象类

　　含有抽象方法类，称为抽象类。
　　1）抽象方法：只有方法的声明（定义），而没有方法的实现的方法，称为抽象方法。
　　　　格式：
　　　　　　abstract 返回值类型方法名(参数列表);
　　2）抽象类的组成：属性，构造方法，抽象方法和非抽象方法
　　　　格式：
　　　　　　abstract class 类名{
　　　　　　　　属性
　　　　　　　　构造方法
　　　　　　　　非抽象方法
　　　　　　　　抽象方法
　　　　　　}
　　　　　　eg：
　　　　　　　　abstract class Car{
　　　　　　　　　　String name;
　　　　　　　　　　String no;
　　　　　　　　　　int speed = 0;
　　　　　　　　　　Car(String name,String no){
　　　　　　　　　　　　this.name = name;
　　　　　　　　　　　　this.no = no;
　　　　　　　　　　}
　　　　　　　　　　void show(){
　　　　　　　　　　　　System.out.println(name+","+no+","+speed);
　　　　　　　　　　}
　　　　　　　　　　abstract void start();
　　　　　　　　　　abstract void run();
　　　　　　　　　　abstract void stop();
　　　　　　　　}
　　　　　　　　案例：Demo4

public class Demo4 {
  public static void main(String[] args) {
//    Car car = new Car();
//不能使用抽象类直接的创建对象。      
    Benz benz = 
        new Benz("宝马","123456","白色",
                "豪华版",200000.1);
    benz.show();
    benz.start();
    benz.run();
    benz.stop();
  }
}
abstract class Car{
//属性
  String name;
  String no;
  String color;
  int speed = 0;
  String type;
//构造方法
  Car(String name,String no,String color,
          String type){
    this.name = name;
    this.no = no;
    this.color = color;
    this.type = type;
  }
  Car(){
      
  }
//非抽象方法
  void show(){
    System.out.println(name+","+no+","+
            color+","+type+","+speed);  
  }
//抽象方法
  abstract void start();
  abstract void run();
  abstract void stop();
}
class Benz extends Car{
//属性
  double price;    
//构造方法
  Benz(String name,String no,
          String color,String type,
          double price){
    this.name = name;
    this.no = no;
    this.color = color;
    this.type = type;
    this.price = price;
  }    
//方法    
  @Override
  void run() {
    System.out.println(name+"在行驶");    
  }
  @Override
  void start() {
    System.out.println(name+"启动了");    
  }
  @Override
  void stop() {
    System.out.println(name+"刹车了");    
  }
}

public class Demo5 {
  public static void main(String[] args) {
    Midea midea = 
        new Midea("美的","壁挂式",
                  5000.33,29,"红色");
    midea.show();
    midea.hot(3);
    midea.cool(5);
  }
}
abstract class Kongtiao{
//属性
  String name;
  String type;
  double price;
  int degree;
//构造方法
  Kongtiao(String name,String type,
          double price,int degree){
    this.name = name;
    this.type = type;
    this.price = price;
    this.degree = degree;
  }    
  Kongtiao(){
  }
//方法
  void show(){
    System.out.println(name+","+type+","
            +degree+","+price);  
  }    
//抽象方法    
  abstract void cool(int degree);
  abstract void hot(int degree);
}
//设计一个抽象类Kongtiao
//属性：名称，类型，价格，温度
//构造方法：1）给每一个属性赋值；2）空参构造方法
//方法：void show():输出每一个属性值
//抽象方法：
//abstract void cool(int degree):
//降低degree度
//abstract void hot(int degree):
//升高degree度
class Midea extends Kongtiao{
//属性：名称，类型，价格，温度，颜色
  String color;
//构造方法
  Midea(String name,String type,
          double price,int degree,
          String color){
    super(name,type,price,degree);
    this.color = color;
  }    
//方法    
  @Override
  void cool(int degree) {
    this.degree = this.degree - degree;
    System.out.println(name+"降低"+degree
        +"度以后，当前的温度是"+this.degree);
  }
  @Override
  void hot(int degree) {
    this.degree = this.degree + degree;
    System.out.println(name+"升高"+degree
        +"度以后，当前的温度是"+this.degree);
  }    
}

　　3）不能直接使用抽象类来创建对象，因为抽象类中含有抽象方法（功能没有实现）。
　　4）编写该抽象类的子类，该子类必须要重写抽象类中所有的抽象方法，实现功能，可以创建该抽象类的子类的对象。
　　5）抽象类是一个用来设计的工具。
　　　　企业开发中，把开发人员分成两类，一类是设计人员(项目经理)，另一类是编码人员（程序员），由设计人员来设计抽象类或者接口，主要设计抽象方法，交给编码人员来编写该抽象类的子类，重写抽象方法，实现功能。
　　6）抽象类侧重是抽象方法的设计，尽量少非抽象方法。

3 final

　　最终的，最后的，可以用来修饰类，属性，方法
　　1）使用final修饰的类，称为最终类。该类不能再被继承。
　　　　案例：Demo6

public class Demo6 {
  
}
final class Zoo1{
    
}
/*
被final修饰的类，不能再被继承(不能再有子类)。
class Zoo2 extends Zoo1{
Math
}
*/

　　　　sun公司设计的工具类，经常使用final进行修饰，比如String,
　　　　Scanner,Math...但是在实际企业中，很少使用final修饰类。
　　2）使用final修饰的方法，称为最终方法。该方法不能再被方法重写。
　　　　案例：Demo7

public class Demo7 {

}
class Moo1{
  final void f1(){
    System.out.println("努力学习，2018快到了");  
    System.out.println("父类Moo1中编写" +
            "方法f1()");
  }    
}
class Moo2 extends Moo1{
/*
被final修饰的方法，不能再被子类方法重写。
  void f1(){
    System.out.println("子类Moo2中重写" +
            "父类Moo1中的方法f1()");  
  }    
*/
}

　　3）使用final修饰的属性，该属性的值一旦初始化以后，其属性值不会再被修改。
　　　　案例：Demo8

public class Demo8 {
  public static void main(String[] args) {
    Yoo1 yoo = new Yoo1();
//    yoo.num = 200;
//被final修饰的属性，其属性一旦初始化以后，其属性值
//不能再被修改。    
  }
}
class Yoo1{
  final int num = 100;
  void updateNum(){
//    num = 200;  
  }
}

4 常量

　　java中的常量外界可以任意的访问（public），常量不依赖于对象而存在，在内存中单独开辟存储空间（static），常量的值永远都不能被修改（final）。
　　1) 定义常量格式：
　　　　public static final 数据类型常量名 = 数值
　　　　或者
　　　　public final static 数据类型常量名 = 数值
　　2) 常量的名字中所有字母建议都大写。
　　　　eg：
　　　　　　public static final double MAX_PRICE = 10000000.99;
　　　　　　public final static double MIN_SALARY = 10000000.99;
　　　　　　public static final String LOGIN_NAME = "admin";
　　　　　　案例：Demo9

public class Demo9 {
  public static void main(String[] args){
//类名.常量名
    System.out.println(Eoo.MIN_PRICE);
    System.out.println(Eoo.MAZ_SALARY);
    System.out.println(Eoo.LOGIN_NAME);
//对象名.常量名
    Eoo eoo = new Eoo();
    System.out.println(eoo.MIN_PRICE);
    System.out.println(eoo.MAZ_SALARY);
    System.out.println(eoo.LOGIN_NAME);
  }
}
class Eoo{
  public static final 
          double MIN_PRICE = 2000000.1;
  public final static
          double MAZ_SALARY = 2000000.99;
  public static final
          String LOGIN_NAME = "admin";
}

　　3) 访问常量：
　　　　类名.常量名
　　　　或者
　　　　对象名.常量名

5 父类声明指向子类对象（了解）

　　使用父类进行声明(定义)对象，使用子类的构造方法来创建对象。
　　1）格式：
　　　　父类对象名 = new 子类构造方法
　　2）使用父类声明指向子类对象这种方式所创建的对象，可以使用从父类中继承过来的方法。
　　　　案例：Demo10

public class Demo10 {
//父类声明指向子类对象：使用父类来声明(定义)对象，
//调用子类的构造方法来创建对象。
//父类  对象名 = new 子类构造方法
  public static void main(String[] args) {
    Noo1 noo = new Noo2();
    noo.f1();
//使用这种方式所创建的对象，可以访问从父类中继承
//过来的方法。    
  }
}
class Noo1{//父类
  void f1(){
    System.out.println("努力学习");
    System.out.println("明天周五");
    System.out.println("在父类Noo1中编写" +
            "方法f1()");
  }    
}
class Noo2 extends Noo1{//子类
    
}

　　3）使用父类声明指向子类对象这种方式所创建的对象，可以使用子类重写父类的方法。
　　　　案例：Demo11

public class Demo11 {
  public static void main(String[] args) {
//父类  对象名 = new 子类构造方法
    Koo1 koo = new Koo2();
    koo.f1();
//使用父类声明指向子类对象这种所创建的对象,可以访问
//子类重写父类的方法。    
  }
}
class Koo1{
  void f1(){
    System.out.println("父类Koo1中编写的" +
            "方法f1()");  
  }    
}
class Koo2 extends Koo1{
  void f1(){
    System.out.println("子类Koo2重写父类" +
            "Koo1中的方法f1()");  
  }    
}

　　4）使用父类声明指向子类对象这种方法所创建的对象，不可以访问子类中单独编写的方法（非继承或者重写）
　　　　案例：Demo12

public class Demo12 {
  public static void main(String[] args) {
    Coo2 coo = new Coo2();
    coo.f1();
    coo.f2();
//父类 对象 = new 子类构造方法
    Coo1 coo2 = new Coo2();
    coo2.f1();
//    coo2.f2();
//使用父类声明指向子类对象这种方式所创建的对象,可以
//访问父类中声明(定义)过的方法(继承或者重写)。不能
//访问子类中单独编写的方法（非继承或者重写）    
  }
}
class Coo1{
  void f1(){
    System.out.println("父类Coo1中编写" +
            "的方法f1()");  
  }    
}
class Coo2 extends Coo1{
  void f1(){
    System.out.println("子类Coo2重写父类" +
            "Coo1中的方法f1()");  
  }
  void f2(){
    System.out.println("子类Coo2中单独" +
            "编写的方法");
  }
}

　　总结：使用父类声明指向子类对象这种方式所创建的对象，可以访问在父类中声明（定义）过方法，不能访问在子类中单独编写的方法。