面向对象
什么是面向对象
- 本质：以类的方式组织代码，以对象的组织(封装)数据。
- 抽象
- 三大特性：封装、继承、多态
- 从认识论的角度考虑是先有对象后有类。对象是具体的事物，类是对象的抽象。
- 从代码运行角度考虑是先有类后有对象。类是对象的模板。
类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一个具体的事物。例如：Person类、Pet类、Cat类等，都是用来描述/定义某一具体的事物应该具备的特点和行为。
- 对象是抽象概念的具体实例，如张三是人的一个具体实例、张三家里的狗旺财就是狗的一个具体实例。
创建与初始化对象
- 使用new来创建对象。
- 使用new关键字创建的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
- 类中的构造器也被称为构造方法，创建对象时必须要调用。有以下特点：1.必须和类的名字相同。 2.没有返回类型，也不能写void。
- 一个类即使什么都不写，也会存在一个默认的构造方法
构造器
public class Person {
//一个类即使什么都不写，也会存在一个默认的无参构造方法
//显示地定义构造器
String name;
//作用：1. 使用new关键字，本质是在调用构造器
//2. 用来初始化对象的值
public Person(){} //无参构造
//有参构造 3.一旦定义了有参构造，无参就必须显示定义
public Person(String name){
this.name=name;
}
//Alt+insert 快捷键插入构造方法
}
封装
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
- 封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。
- 作用：1.提高程序的安全性，保护数据；2.隐藏代码的实现细节；3.统一接口；4.系统可维护性增加了。
//定义一个Student类 public class Student{ //运用private定义私有属性 private String name; private int age; //提供可以操作私有属性的方法 get,set方法 public String getName(){//get 获取这个值 return this.name; } public void setName(String name){//set 设置这个值 this.name = name; } public Int getAge(){//get 获取这个值 return this.age; } public void setAge(Int age){//set 设置这个值 this.age = age; } }//创建个应用类来实现 public class Appliaction{ public static void main(String[] args){ //先实例化对象 Student s1 = new Student(); s1.setName("小明"); System.out.println(s1.getName); } }继承
-
继承的本质是对某一批类的抽象，从而实现对世界更好地建模。
-
extends的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。
-
Java中类只有单继承，没有多继承！一个类只能继承一个父类。
-
继承是类与类之间的一种关系，此外还有依赖、组合、聚合等。
-
继承关系的两个类，一个为子类（派生类），一个为**父类（基类）**子类继承父类。
-
子类和父类之间，从意义上讲应该具有”is a“的关系。
//学生类（子类） 继承 人类（父类）
public class Student extends Person{
//所有类都默认继承Object类
}- 子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承。
- 被final修饰的类，无法被继承（断子绝孙）。
super&this
- super()调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或构造方法中
- **super()和this()**不能同时调用构造方法，因为this也必须写在第一行
- super与this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用。
//定义个Person类，父类 public class Person{ protected String name = "小明"; }//Student类 子类 继承了Person类 public class Student extends Person{ private String name = "小红"; public void test(String name){ System.out.println(name);//小红 System.out.println(this.name);//小红 System.out.println(super.name);//小明 } }public class Person{ protected String name = "小明"; public void print(){ System.out.println("Person"); } }public class Student extends Person{ private String name = "小红"; public void print(){ System.out.println("Student"); } public void test1(){ print();//Student this.print();//Student super.print();//Person } }方法的重写
-
重写：子类的方法必须与父类方法必须一致，方法体不同。
-
重写是方法的重写，与属性无关
-
重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
public class B { public static void test(){ //静态方法 System.out.println("B==>test()"); } }public class A extends B{ //继承 public static void test(){ System.out.println("A==>test()"); } }public class Application { public static void main(String[] args) { //方法的调用之和左边定义的类型有关 A a = new A(); a.test(); //打印 A==>test() //父类的引用指向了子类，但静态方法没有被重写 B b = new A(); b.test(); //打印 B==>test() } }修改A.java,B.java
public class B { public void test(){ //非静态方法 System.out.println("B==>test()"); } } public class A extends B{ @Override //重写了B的方法 public void test() { System.out.println("A==>test()"); } }//父类的引用指向了子类 B b = new A(); //子类重写了父类的方法，执行子类的方法 b.test(); //打印变成了 A==>test() /* 静态方法是类的方法，非静态方法是对象的方法 有static时，b调用了B类的方法，因为b是b类定义的 没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法 */ - 静态方法属于类，非静态方法属于对象
- 注意点：
- 方法名、参数列表必须相同
- 修饰符范围可以扩大，不能缩小（public>protect>private）
- 抛出的异常 范围可以被缩小，不能扩大
- 被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写
多态
...............
接口（interface）
- 普通类：只有具体实现
- 抽象类：具体实现和规范(抽象方法)都有
- 接口：只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程~
- 接口就是规范，定义的是一组规则，"你是什么…必须做什么…"的思想。
- 接口的本质是约束，就像人间法律一样，制定好大家都遵守。
//interface接口,接口都要有继承类 //实现类（implements 可以继承多个接口） //多继承，利用接口实现多继承 public interface UserService { //定义的属性都是常量,默认修饰 public static final public static final int AGE = 99; //一般不用 //所有的定义的方法都是抽象的 默认public abstract public abstract void run(); void add(); void query(); void delete(); }注意点：
- 接口没有构造方法，不能被实例化
- 实现类必须要重写接口中的方法
- 实现类（implements） 可以实现多个接口
内部类
内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B就是A的内部类，而A相对B来说就是外部类。
- 成员内部类：可以操作外部类的私有属性及方法
- 静态内部类：static修饰，不能访问外部类私有属性
- 局部内部类：外部类的方法里定义的类
- 匿名内部类：没有名字初始化类
public class Outer{
private int id;
public void out(){
System.out.println("这是外部类方法");
}
public void Inner{
publid void in(){
System.out.println("这是内部类方法");
}
}
}public class appliaction{
public static void main(String[] args){
Outer outer = new Outer();
//利用外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
}
}
扫一扫
1051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
