面向对象编程
1.初识面向对象
面向过程&面向对象
面向过程思想：
- 步骤清晰简单，第一步做什么，第二步做什么...
- 面向过程合适处理一些较为简单的问题
面向对象思想：
- 物以类聚，分类的思维模式，思考问题首先解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象合适处理复杂问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
什么是面向对象：
面向对象编程（Object-Oriented Programming，OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象：编程思想！ 持续学习，茅塞顿开！ 多实现，多测试大脑中的想法，实践得真知！
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
2.方法回顾和加深
方法的定义：
- 修饰符
- 返回类型
- break：跳出switch，结束循环，return：返回空或者对应类型，结束方法。
- 方法名:注意规范就ok，见名知意
- 参数列表：（参数类型，参数名）...
- 异常抛出：疑问，面向对象后面讲解
方法的调用：递归
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和应用传递
- this关键字
3.类与对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑...
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
对象是抽象概念的具体实例
- 张三是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
4.创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器以下俩个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
构造器必须要掌握
package com.oop.Demo02; public class Person { //一个类即使什么都不写，它也会存在一个方法，与类名相同 // 显示得定义构造器 String name; int age; // // // 实例化初始值 // // 1.使用new关键字，本质是调用构造器 // // 2.用来初始化值 // public Person() { //// this.name = "Dixon"; // } // // //有参构造:一旦定义了有参构造，无参就必须要显示定义 public Person(String neme,int age){ this.name = neme; this.age = age; } // alt + insert 快捷生成构造器 // public Person() { // } /* package com.oop.Demo02; // 一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { // 类：抽象的，实例化 // Person person = new Person(); // System.out.println(person.name); // 输出null // // Person person1 = new Person("Dixon"); // System.out.println(person.name); // 输出null } } 构造器： 1.和类名相同 2.没有返回值 作用： 1.new 本质在调用构造方法 2.初始化对象的值 注意点： 1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造 快捷键： Alt + Insert this. 无参表示当前类的属性值 this. = 传参的值 */ }
5.创建对象内存分
堆：是创建的一些对象；
栈：是一些方法加一些变量的应用；
后续详细讲解
/* 总结： 1.类与对象 类是一个模板：抽象，对象是一个具体的实例 2.方法 定义，调用！ 3.对应的引用 应用类型： 基本类型（8） 对象是通过引用来操作的： 栈--》堆 4.属性：字段 Field 成员变量 默认初始化： 数字：int --》0 fload--》0.0 char: u0000 boolean: false 引用：null 修饰符 属性类型 属性名 =属性值！ 5.对象的创建和使用 -必须使用new 关键字创造对象，构造器 Person dixon =new Person(); -对象的属性 dixon.name -对象的方法 dixon.slepp() 6.类： 静态的属性 属性 动态的属性 方法
封装 继承 多态
*/
6.面向对象三大特性*
封装：
- 该露的露，该藏的藏
- 我们程序设计要追求“高内聚，底耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的大方法给外部使用。
- 封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
- 记住这就句就够了： 属性私有，get/set
package com.oop.demo04; /*总结： 1.提高程序安全性，保护数据； 2.隐藏代码的实现细节 3.统一接口； 4.系统的可维护性增加 */ // 类 private属性私有 public class Student { // 属性私有 private String name; // 名字 private int id; // 学号 private char ser; // 性别 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 >120 || age < 0 ){ //年龄不合法 this.age= 0; }else { this.age = age; } } }
继承：
- 继承的本质就是对某一批类的抽象，从而实现对现实世界的更好的建模。
- extends的意思是“扩展”，子类是父类的扩展。
- Java中类只有单继承，没有多继承！
- 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类，一个威威子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
- 子类和父类之间，从意义上讲应该具有”is a“的关系。
- object类
- ctrl +H 打开族谱，object 就是一个祖宗类
- super与this
- super调用父类的构造方法，必须再构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中！
- super和this不能同时调用构造方法！
- 与this的区别：
- 代表对象不同： this：本身调用者这个对象，super：代表父类对象的引用
- 前提： this：在没有继承的情况也可以使用， super：只能在继承条件才可以使用
- 构造方法：this(); 本类的构造，super()：父类的构造！
- 方法重写----》重点：多态
- 需要有继承关系，子类重写父类的方法！只针对方法，没有重写属性。
- 方法名必须相同。
- 参数列表必须相同，否则就是重载了，重载也是只有在当前类中实现。
- 修饰符： 范围扩大但不能缩小： public > protected > default > private
- 抛出异常：范围可以缩小，但不能扩大：ClassNotFoundException--》Exception（大）
- 重写，子类的方法名和父类必须一样，方法体不同：
- 为什么要重写：
- 父类功能，子类不一定需要，或者不一定满足！
- alt + insert ： override
重写的规则：
- 方法的声明:
权限修饰符 返回值类型 方法名 (形参列表) throus 异常的类型{
//方法体
}
- 约定俗称:子类中的叫重写的方法，父类中的叫被重写的方法
- 田子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
- 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
- 特殊情况:子类不能重写父类中声明为private权限的方法
- 返回值类型:
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型(比如:double)，则子类重写的方法的返回值类型必须是相可的基本数据类型(必须也是double)
- 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型(具体放到异常处理时候讲
- 子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写，要么都声明为static的(不是重写。
多态：
动态编译：类型 可扩展性变强
即同一个方法可根据发送对象的不同采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
注意：
- 多态是方法的多态，属性没有多态性
- 父类和子类，有联系 类型转换异常 ClassCastException！
-
多态存在的条件
- 有继承关系
- 子类重写父类方法,
- 1.static 方法属于类，不属于实例，无法重写
- 2.final 常量，无法重写
- private私有方法：，无法重写
- 父类引用指向子类对象 father f1 = new son();
instanceof （类型转换）引用类型, 判断一个对象是什么类型，总结如下：
- 1.父类引用指向子类的对象
- 2.把子类转换成父类，向上转型，直接转换
- 3.把父类转换成子类，向下转型，需要强制转换，会丢失一些子类的方法
- 4.方便方法的调用，减少重复的代码！ 提高代码有效率，代码简洁！
static：静态方法
package com.oop.demo07; public class Person { // 第二个执行，赋初始值 { // 代码块 （匿名代码块） System.out.println("匿名代码块"); } // 第一个执行,只执行一次 static { //静态代码块 System.out.println("静态代码块"); } //第三个执行 public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person person1 = new Person(); System.out.println("============="); Person person2 = new Person(); } } 输出结果： 静态代码块 匿名代码块 构造方法 ============= 匿名代码块 构造方法
package com.oop.demo07; // 静态导入包 import static java.lang.Math.random; import static java.lang.Math.PI; public class Test { public static void main(String[] args) { // System.out.println(Math.random()); // 没有导入之前需要Math. System.out.println(random()); // 导入后+static，直接调用 System.out.println(PI); } }
7.抽象类和接口
abstract修饰符可以用来修饰方法也可修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类就一定要声明为抽象类。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
package com.oop.demo08; // abstract 抽象类 类 extends：单继承，接口可以多继承 public abstract class Action { // 约束~有人帮我们实现 // abstract，抽象方法，只有方法名字，没有方法实现 public abstract void doSomeThing(); } package com.oop.demo08; // 抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类是abstract，那交给孙子类呗 public class A extends Action{ @Override public void doSomeThing() { } }
接口：
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！ 自己无法写方法~专业约束！ 约束和实现分离：面向接口的编程
接口就是规范，定义的是一组规则，体现现实世界中”如果你是..则必须能...“的思想.例如:如果你是天使,则必须能飞.
接口的本质是契约,就像人类的法律一样,制定好后大家都遵守。
00的精髓，是对对象的抽象，最能体现这一点就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class，声明接口的关键字是interface
总结：
- 约束
- 定义一些方法，让不同的人实现 10---》1
- 方法都是：public abstract
- 常量都是 pubilc static final
- 接口不能被实现化！接口没有构造方法
- implements可以实现多接口
- 必须要重写接口中的方法
----------------UserService package com.oop.demo09; // 抽象的思维!Java // interface 定义的关键字,接口都需要有个实现类 public interface UserService { // public void run(){} //不能写方法 //接口中所有定义其实都是抽象的,接口方法不写public abstract，默认的 //public abstract void run(); // void run(); // 接口方法不写public abstract，默认的 // void run(String name); // 常量~ public static final int AGE =99; //接口中所有定义其实都是抽象的,接口方法不写public abstract，默认的 void add(String name); void delete(String name); void upDate(String name); void query(String name); } ------------TimeService package com.oop.demo09; public interface TimeService { void timer(); } -------UserServiceImpl： package com.oop.demo09; import com.oop.demo09.TimeService; import com.oop.demo09.UserService; // 抽象类: extends // 类可以实现接口,implements接口 //实现了接口的类,就需要重写接口中的方法 // 多继承 利用接口实现多继承 public class UserServiceImpl implements UserService, TimeService { @Override public void timer() { } @Override public void add(String name) { } @Override public void delete(String name) { } @Override public void upDate(String name) { } @Override public void query(String name) { } }
8 内部类
内部类就是一个类的内部在定义一个类，比如A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1.成员内部类
package com.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); } } }
public class Application { public static void main(String[] args) { System.out.println("内部类-------------------------------"); Outer outer = new Outer(); //创建一个外部类对象 //通过这个外部类来实例化 Outer.Inner inner = outer.new Inner(); //成员内部类 inner.in(); inner.getId(); } }
2.静态内部类
package com.oop.demo10; public class Outer { private int id =10 ; public void out(){ System.out.println("这是外部类得方法"); } public static class Inner{ // 静态内部类 public void in(){ System.out.println("这是内部类得方法"); } // 获取外部类的私有属性 public void getId(){ System.out.println(id); // 无法获取私有属性，除非外部类也是static } } }
3.局部内部类
package com.oop.demo10; public class Outer { // 局部内部类 public void method(){ class Inner{ public void in(){ } } } }
4.匿名内部类
package com.oop.demo10; public class Test { public static void main(String[] args) { // Apple apple = new Apple(); // 没有名字初始化类，不用将实例保存到对象中 new Apple().eat(); // 匿名对象 Userservice userservice = new Userservice() { @Override public void hell() { System.out.println("2"); } }; } } class Apple{ public void eat(){ System.out.println("1"); } } interface Userservice{ void hell();
5.lambada
后面再学
posted on 2022-02-23 10:36 Dixon_Liang 阅读(36) 评论(0) 编辑 收藏 举报
