Java学习笔记之---面向对象
（一）封装
（1）封装的优点
- 良好的封装能够减少耦合。
- 类内部的结构可以*修改。
- 可以对成员变量进行更精确的控制。
- 隐藏信息，实现细节。
（2）实现封装的步骤
1. 修改属性的可见性来限制对属性的访问（一般限制为private）
private String sex;
2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问
public void setSex(String s){
this.sex=s;
}
public String getSex(){
return sex;
}
3.可以在set方法中添加条件
public void setSex(String s){
if(sex=="男"||sex=="女"){
sex=s;
}else{
sex="男";
}
}
public String getSex(){
return sex;
}
（3）封装实例
public class Dog {
String name;
String color;
int age;
private String sex;
public void setSex(String s){
if(sex=="男"||sex=="女"){
sex=s;
}else{
sex="男";
}
}
public String getSex(){
return sex;
}
public void eat(){
System.out.println("吃饭");
}
}
class test{
public static void main(String[] args){
Dog dog3=new Dog();
dog3.name="cc";
dog3.age=100;
dog3.setSex("男");
dog3.eat();
System.out.println("狗3的性别为："+dog3.getSex());
}
}
（二）继承
（1）什么是继承
- 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
- 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
（2）继承格式
class 父类 { }
class 子类 extends 父类 { }
（3）继承的优点
- 减少代码的重复，使代码更加整洁
- 提高维护性
- 提高代码的复用性
（4）继承的类型
- 单继承
- 多重继承
- 不同类继承同一个类
- 一个类不能继承多个类
（5）继承的特性
- 父类中的构造方法不能被继承，如果父类中有无参构造方法子类中也要有
- 子类可以继承父类的属性和方法
- 子类继承父类的方法后可以进行重写
- 父类中私有的不能被继承
（6）继承实例
public class Office {
public void print(){
System.out.println("打印");
}
}
public class Excel extends Office {
public void print(){
System.out.println("Excel打印");
}
}
（三）多态
（1）什么是多态
- 多态是同一个行为具有多个不同表现形式或形态的能力。
- 多态就是同一个接口，使用不同的实例而执行不同操作
- 多态性是对象多种表现形式的体现
（2）多态的优点
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
（3）多态存在的必要条件
1.继承 2.重写 3.父类引用指向子类对象
（4）多态实例
1.创建一个父类和两个子类，子类继承父类的属性和方法
public class Animal {
String name;
String age;
public void eat(){
System.out.println("吃饭");
}
}
public class Cat extends Animal {
}
public class Dog extends Animal {
}
2.子类对父类方法进行重写
public class Dog extends Animal {
public void eat(){
System.out.println("狗吃饭");
}
}
public class Cat extends Animal {
public void eat(){
System.out.println("猫吃饭");
}
}
3.父类引用指向子类对象
class test{
public static void main(String[] args){
Animal a=new Cat();
}
}
4.整体实例
public class Animal {
String name;
String age;
public void eat(){
System.out.println("吃饭");
}
}
class test{
public static void main(String[] args){
//向上转型，隐式转型，自动转型，父类引用指向子类对象，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有的方法
Animal a=new Cat();// 向上转型
a.eat(); // 调用的是 Cat 的 eat
//向下转型，强制类型转换，子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法
Cat b=(Cat) a; // 向下转型
b.eat();// 调用的是 Cat 的 eat
show(new Dog());// 以 Dog 对象调用 show 方法
}
public static void show(Animal n){
if(n instanceof Cat){
Cat c=(Cat)n;
c.eat();
}else if(n instanceof Dog){
Dog c=(Dog)n;
c.eat();
}
}
}
public class Dog extends Animal {
public void eat(){
System.out.println("狗吃饭");
}
}
public class Cat extends Animal {
public void eat(){
System.out.println("猫吃饭");
}
}
（四）抽象类
（1）什么是抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
（2）关键字
abstract
（3）抽象方法
- 如果一个类包含抽象方法，那么该类必须是抽象类。
- 任何子类必须重写父类的抽象方法，或者声明自身为抽象类
（4）抽象类的规则
- 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
- 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
- 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能，抽象方法以分号结尾；
- 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
- 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
- static，final，private不能与abstract并存
（5）抽象类实例
public abstract class Animal {
String name;
String age;
public abstract void eat();
}
public class Cat extends Animal {
public void eat(){
System.out.println("猫吃饭");
}
}
（五）接口
（1）什么是接口
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法
（2）关键字
interface implement
（3）接口与类的相似点
- 一个接口可以有多个方法。
- 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
- 接口的字节码文件保存在 .class 结尾的文件中。
- 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
（4）接口与类的区别
- 接口不能用于实例化对象。
- 接口没有构造方法。
- 接口中所有的方法必须是抽象方法。
- 接口不能包含成员变量，除了 static 和 final 变量。
- 接口不是被类继承了，而是要被类实现。
- 接口支持多继承。
（5）接口与抽象类的区别
- 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
- 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
- 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
- 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
（6）接口的特性
- 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
- 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
- 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
- 接口中的方法都是公有的。
- 接口中的方法如果想有方法体，可以借助default或者static实现
（7）接口的实例
public interface Housekeeping {
public void bark();
}
public class Dog implements Housekeeping {
public void bark(){
System.out.println("看见坏人会叫");
}
}
（六）封装--继承--多态--抽象类--接口实例
1.封装
public class Animal {
private String name;
private String color;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setColor(String color){
this.color=color;
}
public String getColor(){
return color;
}
public void eat(){
System.out.println("吃饭");
}
}
class test{
public static void main(String[] args){
Animal a=new Animal();
a.setName("aa");
a.setColor("red");
a.eat();
}
}
运行结果：吃饭
2.继承
public class Animal {
private String name;
private String color;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setColor(String color){
this.color=color;
}
public String getColor(){
return color;
}
public void eat(String name){
System.out.println(name+"吃饭");
}
}
class test{
public static void main(String[] args){
Animal a=new Animal();
a.setName("aa");
a.setColor("red");
a.eat(a.getName());
Cat b=new Cat();
b.setName("bb");
b.setColor("blue");
b.eat(b.getName());
}
}
public class Cat extends Animal{
public void eat(String name){
System.out.println("猫"+name+"在吃饭");
}
}
运行结果：
aa吃饭
猫bb吃饭
3.多态
public class Animal {
private String name;
private String color;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setColor(String color){
this.color=color;
}
public String getColor(){
return color;
}
public void eat(String name){
System.out.println(name+"吃饭");
}
}
class test{
public static void main(String[] args){
Animal a=new Animal();
a.setName("aa");
a.setColor("red");
a.eat(a.getName());
Cat b=new Cat();
b.setName("bb");
b.setColor("blue");
b.eat(b.getName());
Animal c=new Cat();
c.setName("cc");
c.setColor("yellow");
c.eat(c.getName());
Cat d=(Cat)c;
d.eat(d.getName());
}
}
public class Cat extends Animal{
public void eat(String name){
System.out.println("猫"+name+"在吃饭");
}
}
运行结果：
aa吃饭
猫bb在吃饭
猫cc在吃饭
猫cc在吃饭
4.抽象类
public abstract class Animal {
private String name;
private String color;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setColor(String color){
this.color=color;
}
public String getColor(){
return color;
}
public void eat(String name){
System.out.println(name+"吃饭");
}
public abstract void sleep();
}
class test{
public static void main(String[] args){
Cat b=new Cat();
b.setName("bb");
b.setColor("blue");
b.eat(b.getName());
Animal c=new Cat();
c.setName("cc");
c.setColor("yellow");
c.eat(c.getName());
c.sleep();
Cat d=(Cat)c;
d.eat(d.getName());
d.sleep();
}
}
public class Cat extends Animal{
public void eat(String name){
System.out.println("猫"+name+"在吃饭");
}
public void sleep(){
System.out.println("猫在睡觉");
}
}
运行结果： 猫bb在吃饭 猫cc在吃饭 猫在睡觉 猫cc在吃饭 猫在睡觉 5.接口
public abstract class Animal {
private String name;
private String color;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setColor(String color){
this.color=color;
}
public String getColor(){
return color;
}
public void eat(String name){
System.out.println(name+"吃饭");
}
public abstract void sleep();
}
class test{
public static void main(String[] args){
Cat b=new Cat();
b.setName("bb");
b.setColor("blue");
b.eat(b.getName());
Animal c=new Cat();
c.setName("cc");
c.setColor("yellow");
c.eat(c.getName());
c.sleep();
((Cat) c).dark();
Cat d=(Cat)c;
d.eat(d.getName());
d.sleep();
d.dark();
}
}
public interface Housekeeping {
public void dark();
}
public class Cat extends Animal implements Housekeeping{
public void eat(String name){
System.out.println("猫"+name+"在吃饭");
}
public void sleep(){
System.out.println("猫在睡觉");
}
public void dark(){
System.out.println("猫在叫");
}
}
运行结果：
猫bb在吃饭
猫cc在吃饭
猫在睡觉
猫在叫
猫cc在吃饭
猫在睡觉
猫在叫