面向对象三大特征
封装、继承、多态
面向对象的特点（封装继承多态），面向对象编程可以降低项目的耦合性，便于开发
1、封装
隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
//将类中属性私有化 保护属性 ，创建getter和setter方法来进行外边访问
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
封装的优点
- 良好的封装能够减少耦合，符合程序设计追求“高内聚，低耦合”。
- 类内部的结构可以自由修改。
- 可以对成员变量进行更精确的控制。
- 隐藏信息实现细节。
**意义：**封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改
2、继承
JAVA继承指子类可以继承父类的实例域和方法，可以具有父类的相同的行为
如动物是一个父类 他的子类可以有食草动物和食肉动物 两个子类可以继承动物父类的方法和实例域
--子类继承父类
class 父类 {
}
class 子类 extends 父类 {
}
继承可以降低代码的重写率，如两者有大量同样的方法，可以通过创建同一个父类，2子类继承来减少代码的编写，减少代码重写，提高代码的复用性
//狗类
public class Dog {
private String name;
private int id;
public Dog(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
//猫类
public class Cat {
private String name;
private int id;
public Mouse(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
//创建同一父类
public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
继承类型
public class A{
}
public class B{
}
public class C{
}
单继承
A继承B
多重继承
A继承B继承C
不同类继承同一类 指一个父类2个子类继承
BC继承A
继承的特性
- 子类拥有父类非 private 的属性、方法
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
- 子类可以用自己的方式实现父类的方法
- Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类
- 提高了类之间的耦合性
继承关键字-单继承，多实现
extends 是继承
Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
implements 是实现
使用 implements 关键字可以变相的使Java具有多继承的特性，可以实现多个接口
//extends关键字
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}
//implements关键字
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
super 与 this 关键字
super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this 关键字指向自己的引用。
final
类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
提高代码复用性；继承是多态的前提。
继承的优点
(1)提高类代码的复用性
(2)提高了代码的维护性
(3)使得类和类产生了关系，是多态的前提(它也是继承的一个弊端，类的耦合性提高了)
补充：接口 lnterface
接口在java编程语言中是一种抽象类型，是抽象方法的集合，接口通常以interface声明
接口不是类，编写接口的方式和类很相似。类描述对象的属性和方法。接口则包含类要实现的方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
接口与类相似点：
- 一个接口可以有多个方法。
- 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
- 接口的字节码文件保存在 .class 结尾的文件中。
- 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
- 接口不能用于实例化对象。
- 接口没有构造方法。
- 接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
- 接口不能包含成员变量，除了 static 和 final 变量。
- 接口不是被类继承了，而是要被类实现。
- 接口支持多继承。
抽象类和接口的区别
-
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
-
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
-
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
-
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
注意：
1 . JDK 1.8 以后，接口里可以有静态方法和方法体了。JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。更多内容可参考 Java 8 默认方法。
2 . JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。更多内容可参考 Java 9 私有接口方法。
//接口 public interface TestInterface { int i= 1; void add(); //静态方法 static void test(){ System.out.println("接口静态方法！需要1.8之后的jdk"); } //静态方法 public default void test2(){ System.out.println("默认方法需要1.8之后的jdk"); } // private void test3(){ // System.out.println("私有方法，需要1.9之后的jdk"); // } }//抽象类 public abstract class TestAbstract { public static String str = "你好抽象类"; public abstract void test(); public static void test1(){ System.out.println("我要自由飞行"); } public static void main(String[] args) { TestAbstract.test1(); } }
接口的声明
接口的声明语法格式如下：
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
接口有以下特性：
- 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
- 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
- 接口中的方法都是公有的。
接口的实现
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
3、多态
父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。
多态的优点
- 消除类型之间的耦合关系
- 可替换性
- 可扩充性
- 接口性
- 灵活性
- 简化性
案例：
import java.util.Date;
/**
* 实体类的基础父类
*/
public class BasisBean {
public Integer id;
public String remark;
public Date createTime;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
//-------------------------------------------------------
public interface TestInterface {
void add();
}
//-------------------------------------------------------
/**
* 菜品
*/
public class Food extends BasisBean implements TestInterface {
private String name;
private String type;
private Double price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Food{" +
"name='" + name + '\'' +
", type='" + type + '\'' +
", price=" + price +
", id=" + id +
", remark='" + remark + '\'' +
", createTime=" + createTime +
'}';
}
@Override
public void add() {
System.out.println("添加菜品！");
}
}
//-------------------------------------------------------
/**
* 订单详情
*/
public class OrderDetail extends BasisBean implements TestInterface {
private Integer oid;
private Integer fid;
private Integer count;
public Integer getOid() {
return oid;
}
public void setOid(Integer oid) {
this.oid = oid;
}
public Integer getFid() {
return fid;
}
public void setFid(Integer fid) {
this.fid = fid;
}
public Integer getCount() {
return count;
}
public void setCount(Integer count) {
this.count = count;
}
@Override
public String toString() {
return "OrderDetail{" +
"oid=" + oid +
", fid=" + fid +
", count=" + count +
", id=" + id +
", remark='" + remark + '\'' +
", createTime=" + createTime +
'}';
}
@Override
public void add() {
System.out.println("添加选择的菜品！");
}
}
//-------------------------------------------------------
/**
* 订单表
*/
public class Order extends BasisBean implements TestInterface {
private String otable;
private String ostate;
public String getOtable() {
return otable;
}
public void setOtable(String otable) {
this.otable = otable;
}
public String getOstate() {
return ostate;
}
public void setOstate(String ostate) {
this.ostate = ostate;
}
@Override
public String toString() {
return "Order{" +
"otable='" + otable + '\'' +
", ostate='" + ostate + '\'' +
", id=" + id +
", remark='" + remark + '\'' +
", createTime=" + createTime +
'}';
}
@Override
public void add() {
System.out.println("订单添加");
}
}
//-------------------------------------------------------
public class Demo2 {
public static void main(String[] args) {
//实现接口之后，通过实现类进行调用
// Food food = new Food();
// food.add();
//
// OrderDetail orderDetail = new OrderDetail();
// orderDetail.add();
//
// Order order = new Order();
// order.add();
// //通过实现类创建接口对象，通过接口对象调用实现的方法
//// TestInterface testInterface = new Order();
//// testInterface.add();
//作为引入类型，进行方法调用
outAdd(new OrderDetail());
outAdd(new Order());
outAdd(new Food());
}
private static void outAdd(TestInterface testInterface) {
testInterface.add();
}
}
补充：匿名内部类
public class Teacher {
private String name;
public void test1(){
System.out.println("我是老师类中方法！");
}
//内部类
class Student{
public void test1(){
System.out.println("我是学生类中的方法");
}
}
public Student getStudent(){
return new Student();
}
}
//调用
public class Main {
public static void main(String[] args) {
Teacher teacher = new Teacher();
teacher.test1();
//通过提供的方法获取内部类
Teacher.Student student = teacher.getStudent();
student.test1();
//通过new的方式获取
Teacher.Student student1 = teacher.new Student();
student1.test1();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
