1.包

包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护
建包的语法格式：package公司域名倒写，技术名称。包名建议全部小写，且具备意义
建包语句必须在第一行，一般IDEA工具会帮助创建

导包
相同包下的类可以直接访问，不同包下的类必须导包，才能使用。导包格式：import包名.类名
加入一个类中需要用到不同类，而这两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问

2.权限修饰符

权限修饰符：是用来控制一个成员能够访问的范围的
可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制

权限修饰符的分类和具体作用范围
权限修饰符：有四种作用范围由小到大(private->缺省->protected->public)

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

定义成员（方法，成员变量，构造器等）一般满足如下需求
成员变量一般私有
方法一般公开
如果该成员只希望本类访问，使用private修饰
如果该成员只希望本类，同一个报下的其他类和子类访问，使用protected修饰

3.final

final关键字是最终的意思，可以修饰（方法，变量，类）
修饰方法：表示该方法是最终方法，不能被重写
修饰变量：表示该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）
修饰类：表明该类是最终类，不能被继承

final修饰的变量是基本类型：那么变量村粗的数据值不能发生改变
final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的

 public static void main(String[] args) {// final修饰变量final double pi = 3.14;// pi = 1; // 报错final int[] arr = {1,2,3};arr[0] = 2;// arr = {2,3,4}; // 报错，arr中的地址不能被改变}

4.常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变
常量的作用和好处：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性
常量明明规范：英文单词全部大写
多个单词下划线链接

常量的执行原理
在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量
好处是让使用常量的程序的执行性能与直接使用字面量是一样的

public class Constant {public static final String NAME = "张三";public static final Stiring PASSWORD = "123456";
}

5.枚举

枚举是Java中的一种特殊类型
枚举的作用：是为了做信息的标志和信息的分类

定义枚举的格式
修饰符 enum 枚举名称{
第一行都是罗列枚举类实例的名称
}

enum Season {SPRING, SUMMER, AUTUMN, WINTER;
}

枚举的特征：
枚举类都是继承了枚举类型：java.lang.Enum
枚举都是最终类，不可以被继承
构造器的构造器都是私有的，枚举对外不能创建对象
枚举类的第一行默认都是罗列枚举对象的名称的
枚举类相当于是多例模式

Compiled from "Season.java"
public final class Season extend java.lang.Enum<Season> {public static final Sason SPRING = new Season();public static final Sason SUMER = new Season();public static final Sason AUTUMN= new Season();public static final Sason WINTER = new Season();public static Season[] values();public static Season valueOf(java.lang.String);
}

选择常量做信息标志和分类：
虽然可以实现可读性，但是入参值不受约束，代码相对不够严谨
选择枚举做信息标志和分类：
代码可读性好，入参约束严谨，代码优雅，是最好的信息分类！建议使用！

6.抽象类

某个父类知道其所有子类要完成某功能，但是每个子类完成情况都不一样，父类就只定义该功能的基本要求，具体实现由子类完成，这个类就可以是一个抽象类，抽象类其实就是一种不完全的设计图

抽象类必须使用abstract修饰
修饰符 abstat class类名 {}

抽象方法：
就是抽象类中定义的子类必须完成的功能的基本要求

修饰符 abstract 返回值类型 方法名称(形参列表)

没有方法体，只有方法签名，必须abstract修饰

public abstract class Animal {public abstract void run();
}

public class Cat extends Animal{@Overridepublic void run() {System.out.println("猫在跑");}
}

注意：

抽象类是用来被继承的，抽象方法是交给子类重写实现的
一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类

7.抽象类案例

需求：某加油站推出两种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡，后续加油享受8.5折优惠
分别实现2种开篇进入收银系统后的逻辑，卡片需要包含主人名称、余额、支付功能

public abstract class Card {private String name; // 名称private double money;public String getName() {return name;}public void setName(String name) {this.name = name;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}/** 子类要支付，但是每个子类支付的情况不一样，所以父类要把支付定义成抽象方法* */public abstract void pay(double money);
}

public class GoldCard extends Card{@Overridepublic void pay(double money) {double rs = money * 0.8;double lastMoney = getMoney() - rs;System.out.println(getName() + "当前账户" + getMoney() + "消费了"+ rs+ "余额"+lastMoney);setMoney(lastMoney);}
}

public class NomalCard extends Card{@Overridepublic void pay(double money) {double rs = money * 0.9;double lastMoney = getMoney() - rs;System.out.println(getName() + "当前账户" + getMoney()+ "消费了"+ rs+"余额"+lastMoney);setMoney(lastMoney);}
}

public class Test {public static void main(String[] args) {GoldCard c = new GoldCard();c.setMoney(10000); // 父类的c.setName("张三");c.pay(300);NomalCard c2 = new NomalCard();c2.setName("李四");c2.setMoney(5000);c2.pay(300);}
}

特征

有得有失：等到了抽象方法，失去了创建对象的能力
类有的成员（成员变量、方法、构造器）抽象类都具备
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类
不能用abstract修饰变量、代码块、构造器

final和abstract是什么关系

互斥关系
abstract定义的抽象类做为模板让子类继承，final定义的类不能被继承
抽象方法定义通用功能让子类重写，final定义的方法子类不能重写

8.模板方法模式

什么时候使用模板方法模式
使用场景说明：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候

模板方法实现步骤
1.把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码
2.模板方法中不能决定的功能定义成抽象方法让具体子类去实现

案例：银行利息结算系统
需求：某软件公司要为某银行的业务支撑系统开发一个利息结算系统，账户有活期和定期账户两种
活期是0.35%，定期是1.75%，定期如果满10万给予3%的收益
结算利息要先进行用户名、密码验证，验证失败直接提示，登录成功进行结算
分析
···
1.创建一个抽象的账户类Account作为父类模板，提供属性（卡号，余额）
2.在父类Account中提供一个模板方法实现登录验证，利息结算、利息输出
3.具体的连利息结算定义成抽象方法，交给子类实现
4.定义活期账户类，让子类重写实现具体的结算方法
5.定义定期账户类，让子类重写实现具体的结算方法
···

public abstract class Account {private String cardId;private double money;public Account() {}public Account(String cardId, double money) {this.cardId = cardId;this.money = money;}/**登录结算利息*/public void handle(String loginName , String passWord ){// a.判断登录是否成功if("zhangsan".equals(loginName) && "123456".equals(passWord)){System.out.println("登录成功。。");// b.正式结算利息double result =  calc(); // 结算利息了// c.输出利息详情System.out.println("本账户利息是："+ result);}else{System.out.println("用户名或者密码错误了");}}public abstract double calc();public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId = cardId;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}
}

public class CurrentAccount extends Account{public CurrentAccount(String s, int i) {super(s, i);}@Overridepublic double calc() {double result = getMoney() * 0.0175 ;return  result;}
}

public class Test {public static void main(String[] args) {CurrentAccount acc = new CurrentAccount("ABC-111", 100000);acc.handle("zhangsan", "123456");}
}

模板方法建议使用finall修饰，这样会更专业

模板方法是给子类直接使用的，不是让子类重写的，一旦子类重写了模板方法就失效了

模板方法模式解决的问题
1.极大的提高了代码的复用性
2.模板方法已经定义了通用结构，模板不能确定的定义成抽象方法
3.使用者只需要关心自己需要实现的功能即可

9.接口

接口就是体现规范的，其中用冲向方法定义的一组行为规范，接口是更加彻底的抽象
格式

public interface 接口名 {// 常量// 抽象方法
}

JDK8之前接口中只能是抽象方法和常量，没有其他成分了
接口不能实例化
接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化

public interface SportManInterface {// public static final 可以省略不写，接口默认加上String USER_NAME = "张三";// public abstract 可以省略编写，接口默认加上void run();
}

接口的用法：
接口是用来被类实现的（implements），实现接口的类称为实现类，实现类可以理解成所谓的子类
接口可以被类单实现，也可以被类多实现

public interface Law {void rule();
}

public interface SportMan {void run();void competition();
}

public class RunMan implements SportMan,Law{private String name;public RunMan(String name) {this.name = name;}@Overridepublic void rule() {System.out.println(name+"遵守法律");}@Overridepublic void run() {System.out.println(name+"跑步");}@Overridepublic void competition() {System.out.println(name+"比赛");}
}

public class Test {public static void main(String[] args) {RunMan m = new RunMan("张三");m.run();m.rule();m.competition();}
}

基本小结
类和类的关系：单继承
类和接口的关系：多实现
接口和接口的关系：多继承，一个接口可以同时继承多个接口

public interface Law {void rule();
}

public interface People {void eat();
}

public interface SportMan extends Law,People{void run();void competition();void eat();
}

public class JumpMan implements SportMan{@Overridepublic void rule() {}@Overridepublic void eat() {}@Overridepublic void run() {}@Overridepublic void competition() {}
}

接口继承的作用
规范合并，整合多个接口为同一个接口，便于子类实现

JDK8开始后，Java对接口的成员方法进行行新增（允许接口中直接定义带有方法体的方法）
第一种、默认方法
类似之前写的普通实例方法：必须用default修饰
默认会public修饰，需要用接口的实现类的对象来调用

default void run() {System.out.println("run");
}

第二种、静态方法
默认会public修饰，必须static修饰
注意：接口的静态方法必须用本身的接口名来调用

static void inAddr() {System.out.println("恩..");
}
```**第三种、私有方法**
私有的实例方法，必须使用private修饰，从JDK1.9才开始有的
只能在本类中呗其他的默认方法活私有方法访问
```java
private void go() {System.out.println("开始");
}
``````java
public interface SportMan {/** 1.JDK8开始，默认方法* --必须default修饰，默认用public修饰* --默认方法，接口不能创建对象，这个方法只能过继给实现类，由实现类的对象调用* */public default void run() {System.out.println("跑");go();}/** 2.静态方法* --必须使用static修饰，默认public修饰* */public static void Write() {System.out.println("写作业");}/** 3.私有方法(实例方法)* --JDK 1.9开始才支持* --必须在接口内部才能呗方法* */private void go() {System.out.println("开始");}
}
class PMan implements SportMan{}
class Test {public static void main(String[] args) {PMan p = new PMan();p.run();SportMan.Write();}
}
```
接口注意事项
```java
public class Test {public static void main(String[] args) {// 1.接口不能创建对象// 2.一个类实现多个接口，多个及口中有同样的静态方法不冲突// 3.一个类继承了父类，同时有实现了接口，父类中和接口中有同名方法，不冲突，这个类重写该方法即可// 4.一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可// 5.一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承}
}// 5.一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承
interface AAAA {int run();
}
interface BBBB {void run();
}
//interface CCCC extends AAAA,BBBB {//
//}// 4.一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可
interface AAA {default void go() {System.out.println("AAA");}
}
interface BBB {default void go() {System.out.println("BBB");}
}
class CC implements AAA, BBB {@Overridepublic void go() {}
}// 3.一个类继承了父类，同时有实现了接口，父类中和接口中有同名方法，不冲突，这个类重写该方法即可
interface AA {default void eat() {System.out.println("接口吃");}
}
class Animal{public void eat() {System.out.println("Animal吃");}
}
class Cat extends Animal implements AA {}
interface A {static void test() {System.out.println("A");}
}
interface B {static void test() {System.out.println("B");}
}
/*
* 2.一个类实现多个接口，多个接口中同样的静态方法不冲突，原因是接口的静态方法不能呗调用，只能调用自己的
* */
interface C extends A,B {}```

10.Java面向对象进阶2相关推荐

一个视屏的时间教你学会Java面向对象进阶
hello!我又来了,废话不多说,今天我们学习Java面向对象进阶! 面向对象进阶分为:1.成员变量 2.this关键字 3.隐藏和封装 4.static 关键字首先我们要明白什么是成员变量: 1. ...
打怪升级之小白的大数据之旅(二十五)＜Java面向对象进阶之IO流三其他常见流＞
打怪升级之小白的大数据之旅(二十五) Java面向对象进阶之IO流三其他常见流上次回顾上一章,我们学习了常用的字节流与字符流,本章,我会将其他的一些常见的流进行分享,IO流很多,我介绍不完,就挑 ...
Java面向对象进阶
相关额外的代码待上传... /*** 面向对象进阶*/ package com.org.lxh;import com.org.lxh.ext.Demo; import com.org.lxh.impl ...
java接口运动员,JAVA面向对象进阶实例【教练和运动员日常安排】
编程目标分别执行乒乓球和篮球的教练和学生行为,如下: 乒乓球教练|乒乓球学生|篮球教练|篮球学生工作内容|教学 |练乒乓球 | 教学|练篮球餐饮|教练餐 |学生餐 |教练餐 |学生餐额外内容| ...
Java——面向对象进阶（final关键字，static关键字，匿名对象，内部类，四种访问修饰符，代码块）...
一.final关键字继承的出现提高了代码的复用性,并方便开发.但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写.可是当子类继承了这些特殊类之后,就可 ...
小熊教你面向对象进阶的技能！！！
在 Java 语言中对象的属性以成员变量的形式存在,对象的方法以成员方法的形式存在 1.成员变量在java中,变量可以分为成员变量和局部变量,成员变量是在类范围内定义的变量,局部变量是在方法中定义的 ...
Java大数据-Week2-Day2面向对象进阶
第二章第三节面向对象进阶文章目录第二章第三节面向对象进阶前言封装 this关键字静态static 包包2 权限修饰符代码块 main方法详解总结前言 # 第三章第3节面向对象进 ...
Java进阶（一）面向对象进阶简介
一.面向对象进阶简介面向对象知识的学习建议: 多关注语法点的基本作用. 多进行思考和记忆.练习. 要自信,不要在短期想能做什么. 面向对象进阶课程:需要学习哪些语法? static关键字:定义的成员 ...
第十二课 Java基础篇——面向对象进阶（一）
一.Static static表示静态,是Java中的一个修饰符,可以修饰成员方法,成员变量静态变量是随着类的加载而加载的,优先于对象出现的练习1.定义数组工具类需求:在实际开发中,经常会遇到一 ...

10.Java面向对象进阶2

1.包