面向过程&面向对象
- 面向过程思想
- 步骤清晰简单
- 适合处理一些较为简单的问题
- 面向对象思想
- 分类的思考模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行简单独立思考。最后,才对某个分类下的细节进行面向过程的思索。
- 面型对象适合处理复杂的问题,适合处理需要多人协作的问题。
总结:对于复杂事物,为了从宏观上把控,从整体上合理分析,需要以面向对象的思路来分析整个系统,但是,具体到微观操作,仍然需要面向过程的思路去处理。
面向对象
本质:以类的方式组织代码,以对象的组织(封装)数据。
三大特征:1)封装 2)继承 3)多态
构造器详解
package oop;
public class Demo01 {
public static void main(String[] args) {
Person person = new Person();
Person ljh = new Person("ljh");
System.out.println(person.name);
System.out.println(ljh);
}
}
package oop;
public class Person {
String name;
//一个类即使什么都不写,也会存在一个方法
//显示的定义构造器
/*
实例化初始化
2)使用new关键字,本质是在调用构造器
3)用来初始化值
*/
public Person() {
}
//有参构造
public Person(String name){
this.name=name;
}
/*
构造器:
1.和类名相同
2.没有返回值
作用:
1.new 本质在调用构造方法
2.初始化对象的值
注意点:
1.定义了有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
alt+insert 生成构造器
*/
}
封装
- 设计追求”高内聚,低耦合“。
package oop;
/*
1.提高了程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
*/
import oop.demo03.Student;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("ljh");
//String name = s1.getName();
System.out.println(s1.getName());
}
}
package oop.demo03;
public class Student {
//属性私有
private String name;
private int id;
private char sex;
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
继承
- 继承的本质是对某一类对象的抽象,从而实现对现实世界更好的建模。
- extends的意思是“扩展”,子类是父类的扩展。
- JAVA中类只有单继承,没有多继承。(一个儿子只能有一个爸爸,一个爸爸可以有很多儿子)
- 继承是类和类之间的关系,除此之外还有依赖、组合、聚合等关系。
- 子类和父类之间,从意义上讲应该具有“is a”的关系。
1)Object类
package oop;
import oop.demo04.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
}
package oop.demo04;
//Student is Person 子类
public class Student extends Person {
//ctrl + H 继承树
//在java中所有的类都默认直接或间接继承Object类
}
package oop.demo04;
//Person 父类
public class Person {
private int money=1000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
2)继承
package oop;
import oop.demo04.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("lll");
}
}
package oop.demo04;
//Student is Person 子类
public class Student extends Person {
public Student(){
System.out.println("Student执行了");
}
//ctrl + H 继承树
//在java中所有的类都默认直接或间接继承Object类
private String name = "lj";
public void test(String name){
System.out.println(name); //显示Application中输入的name
System.out.println(this.name); //该类中输入的name
System.out.println(super.name);//调用父类中的name
}
}
package oop.demo04;
//Person 父类
public class Person {
public Person(){
System.out.println("Person执行了");
}
protected String name="ljh";
}
结果:
Super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个。
2.super必须只能出现在子类的方法或者构造方法中。
3.super和this不能同时调用构造方法。
Vs this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类
前提:
this:没有继承也能使用
super:只能在继承条件下使用
构造方法:
this():本类的构造
super():父类的构造
3)方法重写
注释:
- 需要有继承关系,子类重写父类的方法。
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大,但不能缩小
- 抛出的异常:可以被缩小,但不能扩大
- 子类和父类方法必须要一致,方法体不同
为什么需要重写:
- 父类的功能,子类不一定需要,或者不一定满足。
package oop.demo05;
public class A extends B {
// public void test(){
// System.out.println("A=>test()");
// }
@Override //重写注释
public void test() {
System.out.println("A=>test()");
}
}
package oop.demo05;
public class B {
public void test(){
System.out.println("B=>test()");
}
}
package oop.demo04;
import oop.demo05.A;
import oop.demo05.B;
public class Application {
public static void main(String[] args) {
//方法的调用只和左边,定义的数据类型有关
A a = new A();
a.test();
//父类的引用指向了子类
B b= new A();
b.test();
}
}
多态
1)
注意事项:
- 多态是方法的多态,属性没有多态
- 父类和子类,有联系
- 存在条件:继承关系、方法需要重写,父类引用指向子类对象
- static 方法,属于类,它不属于实例
- final 常量:
- private方法:
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Person()
//new Student()
//可以指向的引用类型就不确定了:父类的引用指向子类
//Student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person父类型,可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student(); //父类的引用指向子类
Object s3 = new Student();
s2.run();
s1.run();
((Student) s2).eat();
}
}
package oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package oop.demo06;
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
2)instanceof和类型转换
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
Object object = new Student();
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
}
}
package oop.demo06;
public class Person {
}
package oop.demo06;
public class Student extends Person {
}
package oop.demo06;
public class Teacher extends Person {
}
结果:
3)总结
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型:可以直接转换
- 把父类转换为子类,向下转换,强制转换
- 方便方法的调用,减少重复的代码
4)static关键字详解
package oop.demo07;
//static
public class Student {
private static int age; //静态的变量 多线程
private double score; //非静态的变量
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);
// System.out.println(Student.score); 非静态字段不能这样使用
System.out.println(s1.score);
System.out.println(s1.age);
}
}
抽象类
package oop.demo08;
//abstract 抽象类 类 extends: 单继承 (接口可以多继承)
public abstract class Action {
//abstract ,抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
/*
1.不能new这个抽象类,只能靠子类去实现它:约束
2.抽象类中可以写普通的方法
3.抽象方法必须在抽象类中
抽象的抽象:约束
*/
}
package oop.demo08;
//抽象类的所有方法,继承了它的子类,都必须要实现它的方法~ 除非~
public class A extends Action {
@Override
public void doSomething() { //具体的方法
}
}
接口
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有
- 接口:只有规范,自己无法写方法~专业的约束!约束和实现分离:面向接口编程
作用:
(1)约束
(2)定义一些方法,让不同的人实现
(3)接口不能被实例化,接口没有构造方法
(4)public abstract
(5)public static final
(6)implements可以实现多个接口
(7)必须要重写接口中的方法
内部类
package oop.demo10;
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);
}
}
}
package oop;
import oop.demo10.Outer;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getID();
}
}