一、面向过程&面向对象
- 面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么。。。。
- 面向过程适合处理一些简单的问题
- 面向对象思想
- 物以类聚。分类的思维模式，首先需要思考解决问题需要哪些分类，然后再对这些分类进行思考，最后在这些分类中的细节进行面向过程的思考。
- 适合处理复杂的问题
- 对应描述复杂的事物，为了从整体上合理分析、宏观上把握，需要使用面向对象的思维来分析整个系统。但是在具体的微观操作中，仍需要面向过程的思路去处理。
二、面向对象定义
1、面向对象编程(Object-Oriented Programming，OOP)
-
本质：以类的方式组织代码，以对象的组织（封装）数据。
-
核心思想：抽象
-
特性：封装、继承、多态
-
从认识论角度，先有对象后有类。对象，具体的事物。类，对象的抽象。
-
从代码运行角度，先有类后有对象。类是对象的模板。
2、创建与初始化对象
- 使用new创建对象。此时，会分配内存空间，并且会对创建的对象进行默认的初始化以及构造器的调用。
- 类中的构造器又称为构造方法。是创建对象的时候必须要调用的。（重点）
- 构造器的特点：
- 和类名相同
- 没有返回值，也不能带void关键字
- 构造器的作用：
- new本质上是在调用构造方法。
- 初始化创建对象的值。
- 注意点：
- 类中会默认构建一个无参构造，这样用new的时候才不会报错，采用默认的初始化值。
- 当定义了有参构造以后，如果想使用无参构造，必须显式的定义出无参构造
- 构造器的特点：
3、封装
- 高内聚，低耦合。高内聚指类的内部的操作细节由自己完成，不允许外部干涉。低耦合指仅暴露少量的方法给外部使用。
- 属性私有，get/set
- 封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
- 作用：
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了
4、继承
-
本质：对某一批类的抽象，从而实现对现实世界更好的建模。
-
java:extands，只有单继承，没有多继承
-
继承是类与类的关系，除此之外，类与类之间还有依赖、组合、聚合等关系
-
被继承的类是父类，继承的类的子类。
-
子类拥有父类的全部方法。
-
java中，所有的类都默认直接或者间接继承Object类
-
私有的东西无法被继承。即被private修饰的无法被继承。
-
当某个类被final修饰了，就不能再被继承。
-
调用子类无参构造时，默认先调用父类的无参构造。即在子类的无参构造中默认含有super()。
//父类 public class Person { //父类无参构造 public Person() { System.out.println("Person无参构造调用了"); } }//子类 public class Student extends Person{ //子类无参构造 public Student() { System.out.println("Student被调用了"); } }//执行代码 public class Application { public static void main(String[] args) { Student student = new Student(); } }结果为：
Person无参构造调用了
Student被调用了-
可以从结果看到，调用子类无参构造时，首先调用了父类的无参构造。即子类的默认代码为：
//子类无参构造 public Student() { //隐藏代码：调用了父类的无参构造 super();//必须在子类代码的第一行，否则报错 System.out.println("Student被调用了"); }并且，this关键字同样也必须在第一行。
super使用注意点：
（1）使用super()调用父类的构造方法时，必须在子类代码的第一行，否则报错；
（2）super只能出现在子类的方法或构造方法中；
（3）super和this不能同时使用
super Vs this:
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
使用前提：
this：可以直接使用
super：必须有继承条件才能用
构造方法：
this：本类的构造
super：父类的构造
this使用案例：
-
-
class People {
String name = "第一个name";//类中的成员变量并赋值
People(){
}
public void speak() {
String name = "第二个name";//在方法speak中定义和成员变量名字相同的name并赋值
System.out.println(name);
System.out.println(this.name);//通过this来访问类中的成员变量,即第一个name
}
}
public class TestThis {
public static void main(String[] args) {
People myPeople = new People();//等号左边的People是类名，右边的是方法名
myPeople.speak();
}
}
-
若父类含有有参构造而没有显式的定义无参构造，则子类使用无参构造时会报错
-
方法的重写（必须有继承关系，子类重写父类的方法）
-
重写与重载不同。重载是同一个类中，同一个方法名但参数不同。重写是子类和父类中同一个方法名，参数类型也相同。重写必须是子类对父类方法的重写，与属性无关。
public class B { public static void test() { System.out.println("BBBBBBBBBBBBB"); } }public class A extends B{ public static void test() { System.out.println("AAAAAAAAAAAAA"); } }public static void main(String[] args) { //方法的调用只和等号左边定义的数据类型有关 A a = new A(); a.test(); //父类的引用指向了子类 B b = new A(); b.test(); } 结果为： AAAAAAAAAAAAA BBBBBBBBBBBBB但是当由静态方法变为非静态方法时，结果会有变化：
public class B { public void test() { System.out.println("BBBBBBBBBBBBB"); } } public class A extends B{ @Override public void test() { System.out.println("AAAAAAAAAAAAA"); } } 此时再运行上面的main方法，结果变为： AAAAAAAAAAAAA AAAAAAAAAAAAA -
重写（必须有继承关系，子类重写父类的方法）的注意点：
- 方法名必须相同
- 参数列表必须相同
- 方法体不同
- 修饰符：子类的范围可以扩大，但不能缩小。public>protected>default>private
- 抛出的异常：子类抛出的异常范围可以缩小，但不能扩大。
-
5、多态
- 定义：即同一方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的，但引用类型可以是多样的（父类或者有关系的类）
- 多态存在的条件：
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类
详见代码：
//父类
public class Person {
public void run(){
System.out.println("run");
}
}
//子类
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
//执行代码
public class Application {
public static void main(String[] args) {
//一个对象的实际类型时确定的
//new Student();
//new Person();
//引用类型就不确定了：父类的引用指向了子类
//Student可以调用的方法都是自己或者父类的
Student s1 = new Student();
//父类型：可以指向子类，但不能调用子类的方法
Person s2 = new Student();
Object s3 = new Student();
s1.run();
s2.run();//当子类重写了父类的方法，虽然引用类型时父类，但是执行的是子类的方法
//子类含有父类没有的方法时，若引用类型时父类，即使等号右侧是new Student()，仍会报错
//由此可知，对象能执行哪些方法，主要看等号左边的引用类型，和等号右边的关系不大！
s2.eat();//报错
}
}
结果说明：
1、当子类中没有下面这段代码时，
@Override
public void run() {
System.out.println(“son”);
}
执行main方法：
s1.run();
s2.run();
结果为：
run
run2、当子类中含有上述@Override代码时，执行main方法，
结果则为：
son
son
-
多态注意事项：
-
多态是方法的多态，属性没有多态
-
是有联系的类之间的多态，否则会出现类型转换异常
String s2 = new Student();如上述代码，String与Student之间没有联系，此时引用则会出错
-
存在条件：
-
有继承关系
-
方法需要重写
-
重写注意事项：
（1）static方法属于类，它不属于实例，不能重写
（2）final方法属于常量，也不能重写
（3）private方法不能重写
-
-
-
-
instanceof：引用类型，用来测试一个对象是否为一个类的实例，用法为：
boolean result = obj instanceof Class其中obj是一个对象，Class表示一个类或者接口，当obj是Class中的对象，或者是其直接或者间接子类，或者是其接口的实现类，结果result都会返回true，否则返回false。
6、static总结
-
static修饰的表示静态变量或者静态方法，会在代码运行的时候首先运行，并且指运行一次
public class Person { { System.out.println("匿名代码块"); } static { System.out.println("静态代码块"); } public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person person = new Person(); System.out.println("============="); Person person1 = new Person(); } }结果为：
静态代码块
匿名代码块
构造方法 =============
匿名代码块
构造方法由结果可知，带有static的代码先运行，并且只运行一次
-
static可以静态导入包
import static java.lang.Math.random; -
static修饰的变量可以直接用"类名.静态变量"来调用，非静态的变量必须得用对象来调用
public class Demo01 { private static int age;//静态变量 private int score;//非静态\普通 变量 public static void main(String[] args) { Demo01 demo = new Demo01(); System.out.println(Demo01.age);//静态变量可以直接用类调用 System.out.println(demo.score);//非静态变量只能用对象调用 System.out.println(demo.age);//静态变量可以用对象调用 } }静态方法也是同理：
public class Demo01 { public void run(){ go();//非静态方法可以调用静态方法 } public static void go(){} public static void main(String[] args) { go();//静态方法可以直接调用静态方法 //run();//报错，因为静态方法不能直接调用非静态方法 new Demo01().run();//可以使用new来调用非静态方法 }
7、抽象
-
定义：abstract修饰符修饰的类或者方法，修饰类就是抽象类，修饰方法就是抽象方法。见代码：
//abstract放在类上就是抽象类 public abstract class Action { //普通方法 public void doSomething(){} //做一个约束，只有方法名，没有方法实现 public abstract void doSomething1(); }//抽象类的所有方法，它的子类必须要实现它的方法，除非它的子类也是抽象类 public class AA extends Action{ @Override public void doSomething1() { } } -
注意点：
- 抽象类中可以没有抽象方法，但是有抽象方法的类一样要声明是抽象类
- 抽象类中可以有普通的方法
- 抽象类不能用new来创建对象，它是用来让子类继承的
- 抽象方法，只有方法的声明，没有具体的实现，需要它的子类来实现
- 子类继承抽象类，就必须实现抽象类中的抽象方法，否则须声明它也是抽象类
-
思考题
- 抽象类存在构造器么？
- 抽象类存在的意义？
8、接口
定义：接口就是规范，定义了一组规则，体现了现实世界的“如果你是…则必须能…”的思想。它是专业的约束，没有方法，约束和实现分离。见代码：
首先定义UserService接口：
public interface UserService {
//接口中所有的定义都是抽象的，默认都用public abstract修饰,不能用protected等
//public abstract void run();
//void run();//等同于public abstract void run();
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
//接口中也可以定义常量，但是通常不这么做
//默认定义的常量都是由public static final修饰的，可写可不写，通常不写
public static final int AGE = 99;
}
再定义TimeService接口：
public interface TimeService {
void timer();
}
接口的实现：
//类可以实现接口，用implements关键字，此时要实现接口中的所有方法
//类可以实现多个接口，每个接口中的方法都要实现，侧面实现了多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
总结：
（1）接口是约束，定义了不同的方法，可以让不同的人去实现它
（2）接口中所有的定义都是抽象的，默认都用public abstract修饰,不能用protected等
（3）接口中可以定义常量，用public static final修饰的，不推荐在接口中定义常量
（4）接口不能被实例化，接口中没有构造方法
（5）用implements关键字来实现接口，可以同时实现一个或者多个接口，每个接口中的方法都要实现，即通过@Override重写接口中的方法
9、内部类
（1）成员内部类：在某个类中再定义一个类称为内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getId(){
System.out.println(id);
}
}
}
//执行代码
public class Application {
public static void main(String[] args) {
//实例化外部类
Outer outer = new Outer();
outer.out();
//实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
}
}
（2）匿名内部类
public class Test {
public static void main(String[] args) {
//没有名字的初始化类，不用将实例保存到变量中
new Apple().eat();//匿名内部类
}
}
//一个Java类中可以有多个类，但只能有一个类是public
class Apple{
public void eat(){
System.out.println("11111");
}
}
2375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
