概述
面向对象&面向过程
- 面向过程:
- 对一个简单的问题分步解决:第一步做什么,第二步做什么…
- 面向过程适合处理简单的问题
- 面向对象思想:
- 物以类聚:分类的思维模式,首先思考解决问题需要哪些分类,然后对这些分类进行单独思考。最后使用面向过程思维进行解决。
- 面向对象适合处理复杂的问题,适合处理需要多人协作的问题。
- 对于描述复杂的问题,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思维来分析整个系统。但是具体到微观操作,任然需要面向过程的思路去处理。
什么是面向对象
- 面向对象编程(Object-Oriented Programming,OOP)
- 面向对象编程的本质就是:以类的方式封装代码,以对象的方式组织(封装)数据
- 核心思想:抽象
- 将需要解决的问题抽取出其中的属性,进行分项处理
- 三大特性:
- 封装
- 继承
- 多态
- 从认识论的角度去思考就是现有对象后有类。对象是具体的事物,就像人中的小林。类是抽象的,是对对象的抽象概念。比如 ,小林是人 ,小林是具体的人,是一个对象。而人泛指像小林这一类的事物,就是类。
- 从 代码运行的角度考虑是现有对象后有类。类是对象的模板。
回顾方法定义
方法的定义
- 修饰符
- 返回类型
- break 跳出 switch 循环、防止 case 穿透,continue 跳过本次循环。return 结束方法,返回值。
- 方法名:注意规范,见名知意。
- 参数列表:可变参数 (参数类型:形式参数、实际参数…)
- 抛出异常:后面再学。
package OOP;
import java.io.IOException;
//类 Demo01
public class Demo01 {
//方法 main
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名(参数){
//方法体
return 返回值;
}
*/
//return 结束方法,返回结果
//break 跳出 switch 循环,防止case穿透
public String sayhello(){
return "hello world";
}
//返回空值
public void hello(){
return;
}
//比大小的,返回大的值
public static int max(int a ,int b){
return a > b ? a : b;//三元运算符
}
//异常抛出:后面再学 比如数组下表越界ArrayIndexOutOfException
public void readFile(String file)throws IOException {
}
}
方法的调用:递归
静态方法:加了static的方法 public static void say
-
调用方式:类名.方法名
-
package OOP; public class Student { //静态方法 加了static ,调用是使用类名.方法名:Student.say() public static void say(){ System.out.println("上课时说话"); } }
非静态方法的调用
-
先实例化对象,再调用方法
-
package OOP; public class Demp02 { public static void main(String[] args) { /* 调用非静态方法 实例化这个类 new 对象类型 对象名 = 对象值; 对象名.方法; */ Student student = new Student(); student.say(); } }
在同一个类中
- 当方法类型相同时(同为静态或者同为非静态方法时),可以直接相互调用。
- 非静态方法可以直接调用静态方法
- 静态方法不可直接调用非静态方法
形参和实参(参数)
package OOP;
public class Demo03 {
//实参和形参
public static void main(String[] args) {
System.out.println();
System.out.println(Max(30,52));//这里的a、b定义了具体的值,就是实际参数
}
public static int Max (int a,int b){ //这里的a、b就是形式参数,没有定义具体的值
return a > b ? a : b;
}
}
值传递和引用传递
package OOP;
public class Demo04 {
//值传递
public static void main(String[] args) {
int a = 2;
System.out.println(a);//输出2
change(a);
System.out.println(a);//输出2,change方法里面的值并没有被使用
}
//返回值为空
public static void change(int a ){
a = 3;
}
}
package OOP;
//引用传递:传递对象
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
change(person);
System.out.println(person.name);
}
public static void change(Person person ) {
//Person是一个对象:指向-->Person person = new Person();这是一个具体的值,可以改变
person.name = "qilin";
}
}
class Person{
String name;
}
类和面向对象
类和面向对象的关系
类是一种抽象的数据类型,它是对某一类事物的整体描述/定义,是不能代表某一个具体的事物。
- 动物、手机、电脑、植物…
- Person类、Pet类 、Cat类等,这些类都是用来描述/定义某一类事物应该具备的特点和行为
对象是抽象概念的具体实例
- 张山就是人这个类的具体实例,张三家里面的旺财就是狗这个类的具体实例。
- 实例才能体现具体的特点,展现出具体的行为。抽象的概念是没有具体的特点和行为的。
创建与初始化对象
- 使用new关键字创建对象
- 使用 new关键字创建对象的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化及对象中构造器的调用。
- 类中的构造器也称为构造方法,实在创建对象的时候必须要调用的。并且构造器具有 以下两个特点:
- 1.必须和类的名字相同
- 必须没有返回值,也不能写void
- 构造器是必须要掌握的知识
package OOP.Demo02;
import org.w3c.dom.ls.LSOutput;
//创建一个人的类
//一个类中只有属性和方法
public class Person {
// 属性
String name;
int age;
double length;
// 方法
public void study(){
System.out.println(this.name + "在学习");
}
}
package OOP.Demo02;
public class Application {
public static void main(String[] args) {
Person qilin = new Person();//先实例化对象
//person这个对象就是Person这个类的具体实例
//给属性赋值
qilin.name = "qew";
qilin.age = 25;
qilin.length= 168.5;
//打印属性
System.out.println("姓名:"+qilin.name);
System.out.println("年龄:"+qilin.age);
System.out.println("身高:"+qilin.length);
qilin.study();
}
}
构造器详解(构造方法)
- 使用new关键字创建对象时,除了分配内存空间外,还会给创建好的对象进行默认的初始化及对类中构造器的调用
- 在类中创建了一个有参构造器之后,类里面的默认无参构造器就自动消失了,如果创建了有参构造之后还要使用无参构造,那需要创建一个无参构造器。
package OOP.Demo02;
//创建一个人的类
//一个类中只有属性和方法
public class Person {
// 属性
String name;
int age;
double length;
public void person(){
}
// 方法
public void study(){
System.out.println(this.name + "在学习");
}
public Person(String name, int age, double length) {
this.name = name;
this.age = age;
this.length = length;
}
}
package OOP.Demo02;
public class Application {
public static void main(String[] args) {
Person qilin = new Person("漆林",25,168.5);//先实例化对象
//person这个对象就是Person这个类的具体实例
//给属性赋值
//打印属性
System.out.println("姓名:"+qilin.name);
System.out.println("年龄:"+qilin.age);
System.out.println("身高:"+qilin.length);
qilin.study();
}
}
创建对象与内存分析
new一个对象的时候,对象名是放在栈里面,会从方法区中调用一个new的对象的模板,在堆中分配一个地址。输入的属性放在常量池中被调用。https://www.processon.com/diagraming/6193a87be0b34d73f7ff7b32[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M2cJ6DES-1638689540782)(C:\Users\lin\AppData\Roaming\Typora\typora-user-images\image-20211116223211219.png)]
类与对象的简单小结
- 类与对象
- 类是模板,对象是具体的实例
- 方法
- 方法的定义与调用
- 对象的引用
- 八大基本类型,其他的都是引用类型
- 对象是通过引用来操作的
- 属性:也叫字段(Filed)/成员变量
- 默认初始化值:
- 数值(0,0.0)
- char(u0000)
- 布尔值(false)
- 引用类型的初始值:null
- 默认初始化值:
- 对象的创建和使用
- 必须使用new创建对象,必须由构造器才能创建对象 Person qilin = new person();
- 对象的属性:qilin.name
- 对象的方法:qilin.say();
- 类:
- 静态的属性
- 动态的方法
封装
- 该露的露,该藏的藏
- 程序设计要追去“高内聚,低耦合“。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
- 封装(数据的隐藏)
- 通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来完成访问,这称为信息隐藏。
- 属性私有,get/set
- get 获取私有属性,set 给属性赋值
package OOP.Demo04;
//类 private 私有 私有的属性不可以直接赋值
/*
1.提高程序的安全性
2.隐藏代码的实现细节
3.同一接口
4.增加系统的可维护性
*/
public class Student {
private String name;
private int age;
private char sex;
private int id;
//提供一些可以操作这些属性的方法
//get 获取这个数据
//alt + insert 可以快速生成get set
public String getName() {
return name;
}
//set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
//可以限制输入数据区间,保护数据
public void setAge(int age) {
if (age > 150 || age < 0) {
this.age = 0;
}else {
this.age = age;
}
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
package OOP.Demo04;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("漆林");
s1.setAge(958);
System.out.println(s1.getName());
System.out.println(s1.getAge());
}
}
继承
继承的概念
- 继承的本质是堆某一批类的抽象,从而实现堆现实世界更好的建模
- extends的意思是”扩展“。子类是父类的扩展。
- java中的类只有单继承,没有多继承。
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
- **Object是所有类的基类:**在java中所有的类都直接或者间接的继承Object。
super
super的注意点
- super 调用父类的构造方法,必须在构造方法的第一个。
- super 必须只能出现在子类方法或者构造方法中!
- super 和 this 不能同时调用构造方法!(调用无参构造,因为都必须放在第一行)
Vs this:
- 代表的对象不同
- this:本身调用者这个对象
- super:代表父类对象的引用
- 前提
- this:没有继承也可以使用。
- super:只能在继承条件下使用
- 构造方法
- this():只能调用本类的构造
- super():调用父类的构造
package OOP.Demo05;
//**父类**
public class Person {
public Person() {
System.out.println("Person无参执行");
}
public int money = 1000_000_000;
public void say(){
System.out.println("说了你好帅");
}
protected String name = "qilin";
public void print(){
System.out.println("Person");
}
}
package OOP.Demo05;
//**子类**
//学生 is 人 :派生类 子类
//子类继承父类,就会拥有父类的所有方法
public class Student extends Person{
//隐藏代码:先调用了父类的无参构造
public Student() {
System.out.println("Student无参执行");
}
String name = "dalin";
public void name(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
System.out.println("-------------------------------");
}
public void print(){
System.out.println("teacher");
}
public void t1(){
print();
this.print();
super.print();
}
}
package OOP.Demo05;
**输出**
public class Application {
public static void main(String[] args) {
Student student = new Student();
System.out.println("---------------------------");
student.say();
System.out.println(student.money);
System.out.println("------------------------------------");
student.name("xiaolin");
student.t1();
}
}
方法的重写
重写:
需要有继承关系,子类重写父类的方法!
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大 : Public>Protected>Default>Private
- 抛出异常:范围可以被缩小,不能被扩大 :ClassNotFoundException --> Exception(大)
子类的方法名必须一致,但里面的方法提可以不同
为什么需要重写
父类的功能子类不一定需要,或者不一定满足! Alt + insert ;override
package OOP.Demo06;
//重写都是方法的重写,属性不能重写
//只有public的非静态方法能重写,静态方法不能重写
//父类
public class B {
public void t1(){ //
System.out.println("B-->t1");
}
}
package OOP.Demo06;
//子类
public class A extends B {
@Override//注解,带功能的注释 override:重写的意思
public void t1() {
System.out.println("A-->t1");
}
}
package OOP.Demo06;
public class Application {
public static void main(String[] args) {
//方法的调用之和左边部分 就是定义的数据类型有关
A a = new A();
a.t1();//输出A-->t1
//父类的引用指向了子类
B b = new A();
b.t1();//输出A-->t1
}
}
多态
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
- 一个对象的实际类型是确定的,但可以但可以指向对象的引用类型有很多。
- 多态是方法的多态,属性没有多态
多态的注意事项
- 多态是方法的多态,属性煤油多态
- 父类和子类,有联系 否则类型转换异常:ClassCastException!
- 存在条件:
- 存在继承关系,方法需要重写
- 父类的引用指向的子类对象! Father f1 = new Son();
- 不能被重写的方法,不能实现多态:
- static 方法,属于类,不属于实例
- final 常量;
- private 方法
package OOP.Dmeo07;
public class Person {
public void say(){
System.out.println("Person");
}
}
package OOP.Dmeo07;
public class Student extends Person {
public void say() {
System.out.println("Student");
}
}
package OOP.Dmeo07;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
// new Student();
// new Person();
//可以指向的引用类型就不确定了,父类的引用指向子类
//Student 能调用自有和继承父类的方法
Student s1 = new Student();
//Person 只能调用自己的方法,并不能调用Student独有的方法
Person s2 = new Student();
Object s3 = new Student();
s1.say();
s2.say();//子类重写了父类的方法,执行子类的方法
//对象能执行什么方法,取决与左边的类型,与右边关系不大
((Student) s3).say();//强制转换
}
}
instanceof 和类型转换
instanceof
package OOP.Dmeo07;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
// new Student();
// new Person();
//可以指向的引用类型就不确定了,父类的引用指向子类
//Student 能调用自有和继承父类的方法
Student s1 = new Student();
//Person 只能调用自己的方法,并不能调用Student独有的方法
Person s2 = new Student();
Object s3 = new Student();
s1.say();
s2.say();//子类重写了父类的方法,执行子类的方法
//对象能执行什么方法,取决与左边的类型,与右边关系不大
((Student) s3).say("21");//强制转换
System.out.println(s3 instanceof Student);
System.out.println(s3 instanceof Person);
System.out.println(s3 instanceof Techer);//false,因为s3使用的是Student的方法,Student和Teacher不存在父子关系
System.out.println(s3 instanceof String);//false,因为s3使用的是Student的方法,String是line包下的,与object不在同一类里面
System.out.println("-------------------------------------");
System.out.println(s2 instanceof Student);
System.out.println(s2 instanceof Person);
System.out.println(s2 instanceof Techer);//false,因为s2使用的是Person的方法,Student和Teacher不存在父子关系
//System.out.println(s2 instanceof String);//直接报错,因为Student 类与 String类毫无关系
System.out.println("-------------------------------------");
System.out.println(s1 instanceof Student);
System.out.println(s1 instanceof Person);
// System.out.println(s1 instanceof Techer);//Student 和Teacher是平行的,他们不存在任何关系
}
}
类型转换
1.父类的引用指向子类对象
2.向上转型不,可以直接引用。
3.把父类转换为子类,向下转型,需要强制转换,会丢失一些子类特有的方法。
4.方便方法的调用,减少重复的代码。
核心思想:
- 抽象:封装、继承、多态
static修饰符
- 代码执行顺序:静态代码块–>静态方法–>常规代码块–>构造器–>非静态方法
- 静态代码块在程序中只会被执行一次,常规代码块在每个方法执行的时候都会被执行
package OOP.Demo08;
public class Student {
static int age;
double score;
public Student() {
System.out.println("这是一个构造器");
}
public static void say(){
System.out.println("这是一个静态方法");
}
public void say1(){
System.out.println("这是一个动态方法");
}
public static void main(String[] args) {
say();
new Student().say1();
age = 25;
new Student().score = 99;
System.out.println("年龄:"+age +"\n"
+"分数:"+ new Student().score);
}
static {
System.out.println("静态代码块");
}
{
System.out.println("常规代码块");
}
}
package OOP.Demo08;
import static java.lang.Math.random;//静态导入包
public class Ap {
public static void main(String[] args) {
for (int i = 0; i < 8; i++) {
System.out.println(random());//可以直接使用random方法
}
}
}
抽象类
- abstract修饰符可以用来修饰方法也可以用来修饰类,如果用来修饰方法,那么该方法就是抽象方法;如果用来修饰类,那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但抽象方法只能存在与抽象类中,一定要声明为抽象类。
- 抽象类不能使用new关键字来创建对象,它是用来让子类继承的。
- 抽象类只有方法的声明,没有方法的实现,它是用来让子类实现的,
- 子类继承抽象类,那就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
- 继承抽象类必须重写抽象类中的方法。
package OOP.Demo09;
public abstract class Action {//声明为抽象类
//约束,让别人帮我们实现~~
public abstract void doSomething();//abstract抽象方法,可以不定义任何内容,只有方法名,没有方法的实现!
}
package OOP.Demo09;
public class c extends Action{//继承抽象类
@Override//重写抽象类中的方法
public void doSomething() {
}
}
接口
接口 通过interface声明的
- 普通类:只有具体的实现
- 抽象类:具体实现和规范(抽象方法)都有!
- 接口:只有规范!接口中不能实现方法~专业的约束!约束和实现分离;面向接口编程
- 接口就是规范,定义的是一组规则,体现了现实世界中的”如果你是…则必须能…“的思想。如果你是天使,则必须会飞。如果你是汽车,则必须能跑…
- **接口的本质是契约,**就像我们人间的法律一样。制定好之后大家都遵守。
- OO的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(c++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。
接口的作用
- 约束
- 定义一些方法,让不同的人实现~ 10 个人通过不同的方式实现一个接口
- public abstract
- public static final
- 接口不能被实例化
- 可以通过implements实现多个接口
- 必须重写接口中的方法
package OOP.Demo10;
//interface 声明接口,
public interface InterService {
int age = 25;//接口里面的属性都是静态变量,前面自动加了 public static final 的
//接口中的所有定义都是public abstract
void add(int nu1);
void delete(int nu2);
void update(int nu3);
void query(int nu4);
}
package OOP.Demo10;
public interface RunService {
void run(String a);
}
package OOP.Demo10;
//抽象类 只能通过extends实现,只能单继承
//类 可以实现接口 通过 implements 接口 ,可以实现多继承
public class ServiceImpl implements InterService,RunService{//可以实现多继承
@Override //调用接口必须重写接口中的方法
public void add(int nu1) {
}
@Override
public void delete(int nu2) {
}
@Override
public void update(int nu3) {
}
@Override
public void query(int nu4) {
}
@Override
public void run(String a) {
}
}
package OOP.Demo10;
public interface RunService {
void run(String a);
}
内部类
- 内部类就是在一个类的内部在定义一个类。比如,A类中定义一个B类,那么B类相对A类来水就是内部类,而A相对B来说就是外部类了
- 内部类的类型
- 成员内部类
- 动态内部类
- 局部内部类
- 匿名内部类
- 内部接口
- …
package OOP.Demo11;
public class Outer {
private int ID = 9;
public static void out() {
System.out.println("这是外部类的方法");
class one { //这是局部内部类
public static void cc(String[] args) {
System.out.println("局部内部类的方法");
}
}
UserService userService = new UserService() { //实例化内部接口
@Override
public void Study() {
}
@Override
public void Eat() {
}
};
}
public class Inner{ //这是成员内部类
public void m1() {
System.out.println("这是内部类的方法");
}
public void gd(){
System.out.println(ID);//如果内部类变成静态的,那外部类的非静态属性是无法访问的,静态的内部类是和外部类一起加载的,属性是后面加载的
}
}
}
interface UserService{ //内部接口
void Study();
void Eat();
}
import OOP.Demo11.Outer;
public class Text {
public static void main(String[] args) {
Outer outer = new Outer();//先实例化外部类
outer.out();
Outer.Inner i1= outer.new Inner();//实例化内部类
i1.m1();//
i1.gd();//内部类是可以访问外部类的属性(公有和私有属性)
}
}
}
UserService userService = new UserService() { //实例化内部接口
@Override
public void Study() {
}
@Override
public void Eat() {
}
};
}
public class Inner{ //这是成员内部类
public void m1() {
System.out.println("这是内部类的方法");
}
public void gd(){
System.out.println(ID);//如果内部类变成静态的,那外部类的非静态属性是无法访问的,静态的内部类是和外部类一起加载的,属性是后面加载的
}
}
}
interface UserService{ //内部接口
void Study();
void Eat();
}
```java
import OOP.Demo11.Outer;
public class Text {
public static void main(String[] args) {
Outer outer = new Outer();//先实例化外部类
outer.out();
Outer.Inner i1= outer.new Inner();//实例化内部类
i1.m1();//
i1.gd();//内部类是可以访问外部类的属性(公有和私有属性)
}
}