初始面向对象(OPP)
-
面向过程思想
步骤清晰简单,第一步做什么,第二步做什么……
面向过程适合处理一些简单的问题
-
面向对象思想
物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。
面向对象适合处理复杂的问题,适合处理需要多人协助的问题
-
对于描述复杂的事物,从整体上合理分析,使用面向对象的思路来分析整个系统。但是具体到围观操作,仍然需要面向过程的思路去处理。
-
面向对象编程的本质:以类的方式组织代码,以对象的组织(封装)数据。
-
抽象
-
三大特性:封装,继承,多态
方法回顾和加深
方法的调用
-
静态方法
创建一个Stduent类,定义一个静态方法say();
//学生类 public class Student { public static void say(){ System.out.println("学生说话了"); }
创建一个Demo01类,在该类中可直接调用say()方法
//Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { Student.say(); }
输出结果为:学生说话了
-
非静态方法
创建一个Stduent类,定义一个非静态方法say();
//学生类 public class Student { public void say(){ System.out.println("学生说话了"); }
创建一个Demo01类,在该类中需通过实例化Student才可调用say()方法
//Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { //实例化这个类 //对象类型 对象名=对象值 Student student=new Student(); student.say(); } //static :和类一起加载 public static void A(){ //B(); }; // 类实例化 之后才存在 public void B(){ };
输出结果为:学生说话了
两个静态方法可以相互调用,但静态方法不可直接调用非静态方法。因为static方法和类一起加载,非静态方法需要类实例化之后才存在。
-
形参和实参
-
值传递和引用传递
-
值传递:
//值传递 public class Demo02 { public static void main(String[] args) { int a=1; System.out.println("a="+a); Demo02.change(a); System.out.println("a="+a); } //返回值空 public static void change(int a){ a=10; } }
这里两次a输出的值都为1;因为main方法中的a是实参,change中的a是形参,实参并没有改变。
-
引用传递
//引用传递 public class Demo03 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name); Demo03.change(person); System.out.println(person.name); } public static void change(Person person){ //person是一个对象:指向的---->Person person = new Person();这是一个具体的人,可以改变属性 person.name="早点"; } } //定义了一个person类,有一个属性:name class Person{ String name; //null }
这里两次输出结果为null和早点。第一次输出为Person类中name的默认值。第二次输出通过change方法对Person类中的name的值进行了修改,故第二次输出结果为早点。
-
-
this关键字
对象的创建分析
-
使用new关键字创建对象
创建一个Student类
//学生类 public class Student { //属性:字段 String name; //null int age; //0 //方法 public void study(){ System.out.println(this.name+"在学习"); } }
在Application类中实例化和调用Student
//一个项目应该只存一个main方法 public class Application { public static void main(String[] args) { //类是抽象的,需要实例化 //类实例化后会返回一个自己的对象 //student对象就是一个Student类的具体实例 Student xiaoming = new Student(); Student xh = new Student(); xiaoming.name="小明"; xh.name="小红"; xiaoming.age=3; xh.age=3; System.out.println(xiaoming.name); System.out.println(xiaoming.age); System.out.println(xh.name); System.out.println(xh.age); xh.study(); xiaoming.study();
小结:
- 类是抽象的,需要实例化
- 类实例化后会返回一个自己的对象
- student对象就是一个Student类的具体实例
-
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用
-
一个类即使什么都不写,也会存在一个构造方法
定义一个Person类
public class Person { }
在Appliation中实例化Person类
//一个项目应该只存一个main方法 public class Application { public static void main(String[] args) { //使用new关键词实例化了一个对象 Person person = new Person(); } }
点击IDEA右上角的项目结构---->Modules---->Add Content Root,将out文件夹加入列表,out文件里可查看所有class文件,找到Person.class打开,源码如下,可看见构造方法已经存在
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package com.oop.demo02; public class Person { public Person() { } }
-
使用new关键字,本质是在调用构造器
-
构造器一般用来初始化值
-
无参构造
public class Person { //一个类即使什么都不写,也会存在一个构造方法 //显示的定义构造器 String name; //实例化初始值 //1.使用new关键字,本质是在调用构造器 //2.构造器一般用来初始化值 public Person(){ this.name="早点"; }; }
public class Application { public static void main(String[] args) { //使用new关键词实例化了一个对象 Person person = new Person(); System.out.println(person.name); // } }
-
有参数构造:一旦定义了有参构造,无参构造必须显示定义
public class Person { String name; //实例化初始值 public Person(){}; //有参构造:一旦定义了有参构造,无参构造必须显示定义 public Person(String name){ this.name=name; }; //快捷键:alt+inset }
public class Application { public static void main(String[] args) { //使用new关键词实例化了一个对象 Person person = new Person("厉害"); System.out.println(person.name); } }
-
-
构造器的快捷键为Alt+insert
-
-
类中的构造器也成为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void
-
构造器必须要掌握
小结
-
类与对象
类是一个模板:抽象。
对象是一个具体的实例
-
方法
定义、调用
-
对象的引用
引用类型: 基本类型(8)
对象是通过引用来操作的:栈---->堆
-
属性:字段 Field 成员变量
默认初始化:
数字: 0 0.0
char: u0000
boolean:false
引用:null
修饰符 属性类型 属性名=属性值!
-
对象的创建和使用
- 必须使用new关键字创建对象, 构造器 Person zaodian=new Person();
- 对象的属性 zaodian.name
- 对象的方法 zaodian.sleep()
-
类:
静态的属性 属性
动态的行为 方法
-
面向对象三大特性
封装
-
特点
-
高内聚,低耦合
-
属性私有,get/set 快捷键:Alt+insert
-
例子:
//类 private:私有 public class Student { //属性私有 private String name; //名字 private int id; //学号 private char sex; //性别 private int age; //年龄 //提供一些可以操作这个属性的方法 //提供一些public的get,set方法 //get 获得这个数据 public String getName(){ return this.name; } // set 给这个数据设置值 public void setName(String name){ this.name=name; } //快捷键: alt+insert public int getAge() { return age; } public void setAge(int age) { if (age>20 ||age<0){ this.age=3; }else{ this.age = age; } } }
public class Application { public static void main(String[] args) { Student s1 = new Student(); s1.setName("早点"); System.out.println(s1.getName()); s1.setAge(999); System.out.println(s1.getAge()); } }
-
-
作用
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高系统可维护性
继承
继承的特点
-
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模
-
继承是类与类之间的一种关系。除此之外,类与类之间的关系还有依赖、组合、聚合等。
-
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
-
子类和父类之间,从意义上将应该具有”is a“的关系。
-
子类继承了父类,就会拥有父类的全部方法(public)
-
查看继承关系的快捷键: ctrl+H
-
在java中,所有类都直接或间接继承了Object类
-
举例:
父类Person
//人 public class Person { //public private default protected private int money=10_0000_0000; public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } public void say(){ System.out.println("说了一句话"); } }
子类Student和Teacher
public class Student extends Person{ //查看继承关系 ctrl+H } //Teacher is 人 public class Teacher extends Person{ }
super
创建Student类继承自Person类,测试主类为Application
-
属性的继承
public class Student extends Person{ private String name="夏夏";j 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="早点"; }
//一个项目应该只存一个main方法 public class Application { public static void main(String[] args) { Student student = new Student(); student.test("zaodian"); } }
输出结果为:zaodian 夏夏 早点
-
方法的继承
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(); this.print(); super.print(); } }
public class Application { public static void main(String[] args) { Student student = new Student(); student.test1(); } }
输出结果为:Student Student Teacher
-
构造器
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无参执行了
∴子类默认调用了父类的无参构造
-
注意点
super注意点: 1. super调用父类的构造方法,必须在构造方法的第一个 2. super 必须只能出现在子类的方法或者构造方法中 3. super和this不能同时调用构造方法! Vs this: 代表的对象不同: this:本身调用者这个对象 super:代表父类对象的应用 前提 this:没有继承也可以使用 super:代表父类对象的引用 构造方法 this();本类的构造 super();父类的的构造!
方法重写
重写:需要有继承关系,子类重写父类的方法!
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
4. 抛出的异常:范围可以被缩小,但不能扩大;
重写,子类的方法和父类必须一致,方法体不同!
为什么需要重写:
1.父类的功能,子类不一定需要,或者不一定满足
Alt+Insert : Override
举例:A类继承B类
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
// Override 重写
@Override //注解:有功能的注释
public void test() {
System.out.println("A=>test");
}
}
public class Application {
//静态方法和非静态的方法区别很大
//非静态:重写
//
public static void main(String[] args) {
A a = new A();
a.test(); //A
//父类的引用指向的子类
B b=new A(); //子类重写的父类的方法
b.test();
}
}
输出结果为A=>test A=>test
多态
举例和注意点
-
多态是方法的多态,属性没有多态
-
父类的和子类有联系 类型转换异常 ClassCastException
-
多态存在条件:继承关系,方法需要重写,父类引用指向子类对象 Father f1=new Son();
-
static 方法属于类,不属于实例,没有多态;final 常量和private方法也没有多态
-
对象能执行哪些方法,主要看对象左边的类型,和右边关系不大!
-
子类能调用的方法都是自己的或者继承父类的;父类可以指向子类,但是不能调用子类独有的方法,所以一个对象的类型是确定的,但可以指向对象的引用的类型有很多(父类)
-
动态实现:动态编译:类型:可扩展
instanceof (类型转换)
引用类型,可用来判断一个对象是什么类型
举例:Student,Teacher,Person,Application类
**System.out.println(x instanceof y); **判断编译是否可以通过
public class Person {
}
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
// Object>Person>Student
// Object>person>Teacher
Object object = new Student();
//System.out.println(x instanceof y); //true
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
System.out.println(object instanceof String); //false
System.out.println("====================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //
public class Teacher {
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.go();
//子类转换为为父类,可能会丢失自己的本来的一些方法
Person person = new Student();
person.go();
//类型之间的转换: 父--子
Person obj = new Student();
//student将这个对象转换成Student类型,我们就可以使用Student类型的方法了
((Student)obj).go();
}
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型;
3.把父类转换为子类,向下转换: 强制转换
4.方便方法的调用,减少重复的代码!简洁代码
- 类型转换的特点:
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型;
- 把父类转换为子类,向下转换: 强制转换
- 方便方法的调用,减少重复的代码!简洁代码
static
-
final之后,断子绝孙(被final修饰的类不可再被继承)
-
代码块和静态代码块
代码块加载顺序:
- 静态代码块,且仅执行一次,可用来赋初值
- 匿名代码块
- 构造方法
public class Person { { //2.第二加载代码块(匿名代码块) System.out.println("代码块"); } static{ //1.第一加载静态代码块,仅执行一次,可用来赋初始值 System.out.println("静态代码块"); } //3.第三加载 public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person person = new Person(); System.out.println("================="); Person person1 = new Person(); } }
-
导入包时,加上static修饰
package com.oop.demo07; //静态导入包 import static java.lang.Math.PI; import static java.lang.Math.random; public class Test { public static void main(String[] args) { System.out.println(Math.random()); //没有静态导入包时 System.out.println(random()); //静态导入后可直接使用 System.out.println(PI); } }
抽象类和接口
抽象类
定义一个抽象类Action
//abstract 抽象类 类:单继承~ (接口可以多继承)
public abstract class Action {
//约束~有人帮我们实现
//abstract ,抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
//1.不能new这个抽象类,只能靠子类去实现它:约束!
//2.抽象方法必须在抽象类中,抽象类中可以写普通的方法
}
定义一个A类继承Action
//抽象类的所有方法,继承了它的子类,都必须要实现它的方法~
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
声明类的关键字是class,声明接口的关键字是interface
-
通俗解释:
- 递进关系:
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有
- 接口:只有规范!自己无法写方法专业的约束!约束和实现分离:面向接口编程
- 接口就是规范,定义的是一组规则,体现了现实世界中“如果你是……则必须能……”,接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
- 递进关系:
-
注意点和性质:
定义两个接口TimeService和UserService,类UserServiceImpl去实现接口
//抽象的思维 Java 架构师 //interface 定义的关键字, 接口都需要有实现类 public interface UserService { //接口中的常量 public static final public static final int age=99; //接口中的所有定义其实都是抽象的 public abstract void add(String name); void delete(String name); void update(String name); void query(String name); }
public interface TimeService { void timer(); }
//抽象类:extends
//类 可以实现implements 接口
//实现了接口的类,就需要重写接口中的方法
//接口实现类命名Impl结尾 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. 定义一些方法,让不同的人实现~
3. public abstract 接口中的方法
4. public static final 接口中的变量
5. 接口不能被实例化,接口中没有构造方法
6. implements 可以实现多个接口
7. 必须要重写接口中的方法~
内部类和OOP实战
内部类就是在一个类的内部再定义一个类
-
成员内部类
-
静态内部类
-
局部内部类
//外部类 public class Outer { private int id; public void out(){ System.out.println("这是外部类的方法"); } //局部内部类 public void method(){ class Inner1{ } } //成员内部类 加static为静态内部类 public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //get外部类的私有属性 public void getID(){ System.out.println(id); } } }
public class Application { public static void main(String[] args){ Outer outer = new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner = outer.new Inner(); inner.getID(); } }
-
匿名内部类
public class Test { public static void main(String[] args) { //匿名内部类 没有名字初始化类,不用将实例保存到变量中 new Apple().eat(); } } class Apple{ public void eat(){ System.out.println("1"); } }