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中单独" + "编写的方法"); } }
总结:使用父类声明指向子类对象这种方式所创建的对象,可以访问在父类中声明(定义)过方法,不能访问在子类中单独编写的方法。