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