Java语言基础(14)

Wesley13
• 阅读 274

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中单独" +
            "编写的方法");
  }
}

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

点赞
收藏
评论区
推荐文章
光头强的博客 光头强的博客
1个月前
Java面向对象试题
1、 请创建一个Animal动物类,要求有方法eat()方法,方法输出一条语句“吃东西”。 创建一个接口A,接口里有一个抽象方法fly()。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”,重写eat()方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象,调用eat方法。然后向下转型调用eat()方
Wesley13 Wesley13
1年前
Java类和对象
一、类 --- 类是封装对象的属性和行为的载体,在Java语言中对象的属性以成员变量的形式存在,而对象的方法以成员方法的形式存在。 1\. 类的构造方法 **构造方法是一个与类同名的方法**,对象的创建就是通过构造方法完成的,构造方法分为有参构造方法和无参构造方法,区别就在于有没有参数。说这么多概念是不是感觉有点麻木,直接看下面的例子吧。 pub
Wesley13 Wesley13
1年前
Java基础入门
类别 关键字 说明 访问控制 private 私有的 protected 受保护的 public 公共的 类、方法和变量修饰符 abstract 声明抽象 class 类 extends 扩充,继承 final 最终值,不可改变的 implements 实现(接口) interface 接口 native 本地
Stella981 Stella981
1年前
ES6入门六:class的基本语法、继承、私有与静态属性、修饰器
* 基本语法 * 继承 * 私有属性与方法、静态属性与方法 * 修饰器(Decorator)  一、基本语法 ------- 1 class Grammar{ 2 constructor(name,age){ //定义对象自身的方法和属性 3 this.name = name,
Wesley13 Wesley13
1年前
java中一些常考知识
一、static的作用 -----------   static是修饰符,用于修饰成员变量(静态变量/类变量)。 static修饰的成员被所有对象共享。 static优先于对象存在。 static修饰的成员可以用类名.静态成员来访问。 注:1.静态方法只能访问静态成员,非静态方法既能访问静态成员又可以访问非静态成员。 2.静态方法中不可
Wesley13 Wesley13
1年前
Java修饰符类型
修饰符是一种添加到定义以更改其含义的关键字。Java语言有各种各样的修饰符,包括以下两种 - * Java访问修饰符 -例如:`private`,`protected`,`public`等。 * Java非访问修饰符 -- 例如:`static`,`final`等。 要使用修饰符,请在类,方法或变量的定义中包含修饰符关键字。 修饰符位于语句之前,
Wesley13 Wesley13
1年前
java常用API之System类
System中代表程序所在系统,提供了对应的一些系统属性信息,和系统操作。System类不能手动创建对象,因为构造方法被private修饰,阻止外界创建对象。System类中的都是static方法,类名访问即可。 常用方法: ![](https://images2018.cnblogs.com/blog/1451598/201808/1451598-20
Wesley13 Wesley13
1年前
Java 语言的类、属性、方法各有哪些修饰符?简述各修饰符的区别
1、 类的修饰符分为:可访问控制符和非访问控制符两种。 可访问控制符是:公共类修饰符 public 非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final       1、公共类修饰符 public : Java 语言中类的可访问控制符只有一个: public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工
Wesley13 Wesley13
1年前
java常用的关键字
### 1、final关键字 final关键字可用于修饰类、方法以及变量。 修饰类:该类不能被继承,该类的所有方法和成员都被隐式地指定为final。 修饰方法:锁定方法,任何继承类都不能修改他,所有的private方法都被隐式地指定为final方法。 修饰变量:若修饰的变量为基本数据类型,该变量值被赋值后不可改变;若修饰的变量为引用类型的变量,该变量
Wesley13 Wesley13
1年前
Java中的权限修饰符
Java中修饰符总结: ----------- 1. 访问控制修饰符  > 作用: 用于控制被修饰变量、方法、类的可见范围.  > public 的访问级别是最高的,其次是 protected、默认和 private.  > 成员变量和成员方法可以处于4个访问级别中的一个:公开、受保护、默认或私有.