1. 什么是面向对象
面向过程：从上到下一步步按顺序执行 线性思维
面向对象：物以类聚，分类的模式
面向对象编程：本质是以类的方式组织代码，以对象的形式（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态
先有对象后有类，对象是具体的事物，类是对对象的抽象
从代码层面，先有类后有对象，类是对象的模板。
2. 回顾方法及加深
方法定义：
修饰符/返回类型/switch/break return区别/方法名/参数列表/异常抛出
方法的调用：
静态方法/非静态方法/形参和实参/值传递和引用传递/this关键字
3. 回顾方法调用
静态方法，直接类名.方法名；
非静态方法，实例化类，用类对象调用。
静态方法不能调用非静态方法；（前者和类一起存在，后者实例化后才存在，存在调用不存在，所以不行）
非静态方法是可以调用静态方法的。
值传递：
//值传递
public class Demo02 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
// 虽然调用传进去1，但是a形参是临时变量,和内部的a不是一个东西
Demo02.change(a);
System.out.println(a); // 1 java是值传递
}
public static void change(int a) {
a = 10;
}
}
引用传递：传递对象，本质还是值传递
//引用传递
public class Demo03 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); // null
Demo03.change(person);
System.out.println(person.name); // 蔡运来
}
public static void change(Person person) {
// person是一个对象，指向类的实例，是具体的人，可以改变值
person.name = "蔡运来";
}
}
//定义一个Person类
class Person{
String name;
}
4. 类与对象的创建
类与对象的关系：
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 对象是抽象概念的具体实例
创建与初始化对象：
-
使用new关键字创建对象
-
此时，除了分配内存空间外，还会给 创建好的对象 进行默认的初始化以及 对类中构造器的调用。
-
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下两个特点：
-
- 必须和类的名字相同；
- 必须没有返回类型，也不能写void
-
// 学生类
public class Student {
// 属性： 字段
String name; // null
int age; // 0
// 方法
public void study() {
System.out.println(this.name+"学生在学习");
}
}
// 一个项目应只存在一个main方法
public class Application {
public static void main(String[] args) {
// 类是抽象的，实例化才能使用
// 实例化返回一个自己的对象
Student student = new Student();
student.name = "小明";
student.age = 3;
System.out.println(student.name + student.age); // name为赋值前默认是null
}
}
5. 构造器详解
构造器必须要掌握！
默认无参构造；
使用new本质在调用无参构造器；
使用有参构造时，必须显示定义无参构造
public class Person {
// 一个空类也会有一个构造方法
// 显示定义构造器
String name;
// 1. 构造器第一个作用，实例化初始值
// 使用new关键字，本质是在调用构造器
public Person(){
this.name = "Qinjiang";
}
// 有参构造器
// 一旦定义有参构造，无参构造必须显式定义！
public Person(String name) {
this.name = name;
}
// Alt + insert 生成构造器
}
public class Application {
public static void main(String[] args) {
// new关键字实例化一个对象
Person person = new Person("zhangsan");
System.out.println(person.name);
}
}
6. 创建对象内存分析
public class Pet {
public String name;
public int age;
public void shout(){
System.out.println("叫了一声");
}
}
public class Application {
public static void main(String[] args) {
Pet dog = new Pet(); // 第①步
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
第①步如下：
第②步：
第③步：
Pet cat = new Pet();
栈中引用对象名指向的是堆中的数据。
方法区也属于堆。jdk8以后方法区移到本地内存了。
7. 小结
- 类与对象
类是一个模板： 抽象； 对象是一个具体的实例
- 方法
定义、调用！
- 对象的引用
引用类型： 基本类型（8）
对象是通过引用来操作的： 栈->堆
- 属性： 字段Field 成员变量
默认初始化： 数字，char，boolean，引用
修饰符 属性类型 属性名 = 属性值
- 对象的创建和使用
必须用new关键字创建对象，调用构造器
对象的属性/方法
- 类
静态的属性 属性
动态的行为 方法
8. 封装
- 该露的露，该藏的藏
程序设计要求 高内聚，低耦合
- 封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过接口来访问。
- 属性私有 get/set
public class Student {
private String name; // 名字
private int id; // 学号
private char sex; // 性别
// 提供一些可以操作这个属性的方法
// 提供一些public的get、set方法
// get 获取这个数据
public String getName(){
return this.name;
}
// set 给这个属性设置值
public void setName(String name){
this.name = name;
}
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("Qinjiang");
System.out.println(s1.getName());
}
}
鼠标右键 generate 生成 set/get方法。
封装的意义：
- 提高程序安全性，保护数据
- 隐藏代码实现细节
- 统一接口
- 提高系统的可维护性
方法重载：比如println的重载方法
9. 继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
java中只有单继承，没有多继承！
继承是类和类之间的一种关系；
继承关系的两个类，一为子类（派生类），一为父类（基类）。子类继承父类，使用关键字extends表示。
子类获得父类所有的public属性和方法。
// Person 人
public class Person {
public void say(){
System.out.println("说了一句话");
}
}
// Student 学生 人
public class Student extends Person{
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
Ctrl + H 右侧显示继承树
在Java中所有的类都默认继承Object类（祖宗类） , java.lang包下
10. 继承之super
super — 父
this — 自己
// Person 人
public class Person {
protected String name = "Qinjiang";
}
public class Student extends Person{
private String name = "zhangsan";
public void test(String name){
System.out.println(name); // 传递给的参数
System.out.println(this.name); // 本类的属性值
System.out.println(super.name); // 父类的该属性值
}
}
// 一个项目应只存在一个main方法
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("李四");
}
}
// 输出
李四
zhangsan
Qinjiang
默认子类new对象时，先调用父类构造器，在调用子类构造器；另外，调用的父类构造器必须要在子类构造器的第一行。this同理。
// Person 人
public class Person {
public Person(){
System.out.println("Person无参执行了");
}
protected String name = "Qinjiang";
public void say(){
System.out.println("person说了一句话");
}
}
public class Student extends Person{
public Student(){
// 默认调用super()父类构造器
System.out.println("Student无参执行了");
}
private String name = "zhangsan";
public void test(String name){
System.out.println(name); // 传递给的参数
System.out.println(this.name); // 本类的属性值
System.out.println(super.name); // 父类的该属性值
}
public void say(){
System.out.println("student说了一句话");
}
public void test1(){
say();
this.say();
super.say();
}
}
一个类必有一个无参构造。
小结：super注意点
- super调用父类的构造方法，必须在构造方法第一个
- super必须只能出现在子类的方法或构造方法中
- super和this不能同时调用构造方法
- super代表父类对象的引用，只有继承情况下才可使用；this本身调用者，没继承也可用；
- 构造方法：this() 本类构造 super() 父类构造
11. 继承之方法重写
方法static修饰：（静态方法不叫重写）
public class A extends B{
public static void test(){
System.out.println("A=>test()");
}
}
public class B {
public static void test(){
System.out.println("B=>test()");
}
}
public class Application {
public static void main(String[] args) {
// 方法的调用只和左边定义的数据类型有关
A a = new A();
a.test(); // 调用A类方法
// 父类的引用指向了子类 !!!
B b = new A();
b.test(); // 调用B类方法
}
}
方法的重写（去掉static修饰的普通方法）：
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
@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类方法
}
}
//输出
A=>test()
A=>test()
因为非静态方法子类重写了父类的方法，相当于覆盖了父类方法，所以new的子类实例调用的就是子类方法。
总结:
-
前提：继承关系，且子类重写父类的方法
-
方法名必须相同
-
参数列表必须相同
-
修饰符：范围可以扩大，但不能缩小 public > protected > default > private (即子类可以扩大父类方法的范围重写)
-
抛出的异常：范围可以缩小但不能扩大（异常抛出范围不能大于父类） 例如：ClassNotFoundException–>Exception
-
子类父类方法相同，方法体不同
为什么要重写？
- 父类功能子类不需要/不满足
12. 多态
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的（new谁就是谁），但可以指向对象的引用的类型有很多
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 多态 是方法的多态，属性没有多态
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
// @Override
// public void run() {
// System.out.println("son run");
// }
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
Person s2 = new Student(); // 父类引用指向子类对象
Object s3 = new Student();
s2.run(); // 子类重写父类方法后，都执行子类方法
s1.run(); // 子类没有重写父类方法时，都执行父类方法
}
}
子类可调用方法是 自己的或继承父类的；
父类只能调用自己的，不能调用子类独有的。
多态注意事项：
-
父类和子类有联系才行，否则强转出现类型转换异常
-
被static/final/private修饰的方法不能被重写
-
运行期间才确定调用谁的方法
13. instanceof和类型转换
判断一个对象是什么类型。
对象名 instanceof 类名 //判断对象是否属于某一类类型
x instanceof y
两者有关系(x和y父子关系)才会编译通过，再去判断是不是该类型
// Person父类，Teacher/Student子类
public class Application {
public static void main(String[] args) {
// Object > Person > Student
// Object > Person > Teacher
// Object > String
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
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);//false
//System.out.println(person instanceof String);//编译就报错
System.out.println("====================================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译就报错
//System.out.println(student instanceof String);//编译就报错
}
}
类型转换：
- 父类引用指向子类对象
- 把子类转换为父类 向上转型；
- 把父类转换为子类，向下转型，要强制转换；
- 方便方法调用，不需要重新new类，减少重复代码
public class Application {
public static void main(String[] args) {
//类型之间的转化 父 子
//高 低
Person obj = new Student();
// obj想访问Student类的say方法,但是编译不通过
//将这个obj对象转化为Student类型，就可以使用Student类的方法了
// 高 低 强转
((Student) obj).say();
//低转高，子类转父类对象失去访问自己方法的权限
Student student = new Student();
student.say();
Person person = student; //低转高自动就转过去了
person.say();//报错，无法访问Student类方法
}
}
14. static关键字讲解
使用一：
public class Student {
private static int age; //静态变量
private double score; //非静态变量
public void run(){
go(); //非静态方法可以调用静态方法
}
public static void go(){
// 静态方法随类加载而加载，普通方法还未加载，所以访问不到
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.score); // 输出内容+ .sout回车
System.out.println(s1.age);
System.out.println(Student.age); // 直接类名调用
Student.go();
}
}
public class Person {
{
//代码块（匿名代码块）创建对象时产生，在构造器之前
}
static {
//静态代码块 随类加载，永远执行一次
}
}
public class Person {
// 2 可通过这里赋初值
{
System.out.println("匿名代码块");
}
//执行顺序 1 但是只执行一次（尽管new多个对象）
static {
System.out.println("静态代码块");
}
// 3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("==================");
Person person2 = new Person();
}
}
//输出
静态代码块
匿名代码块
构造方法
==================
匿名代码块
构造方法
使用二：
//静态导入包~
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());
//当不想输入Math类，只想输入random时
//使用静态导入包，看最上面
System.out.println(random());
}
}
另外，final修饰常量，被修饰的类不能被继承。
15. 抽象类
- abstract 修饰符可以用来修饰方法也可以修饰类，修饰方法，方法就是抽象方法；修饰类，类就是抽象类；
- 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类；
- 抽象类，不能用new关键字来创建对象，它是用来让子类继承的；
- 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的；
- 子类继承抽象类，就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
// abstract 抽象类 单继承
// java 接口可以多继承
public abstract class Action {
// 约束，让别人帮我们实现
// 抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
// 1. 不能new这个抽象类，只能靠子类去实现它 这就是约束
// 2. 抽象类可以有普通方法
// 3. 抽象方法必须在抽象类中
// 思考： 不能new，那存在构造器吗？
// 抽象类存在的意义？ 将共有属性方法抽象出来
}
//抽象类的所有抽象方法，继承了它的子类都必须实现，否则(除非)该子类也是抽象类
public class A extends Action{
@Override
public void doSomething(){
}
}
16. 接口的定义与实现
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有
- 接口：只有规范 没有实现 ---------约束和实现分离：面向接口编程
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。例如如果你是汽车，则必须能跑
- 接口的本质是契约，就像我们的法律一样，大家一起遵守
- OO的精髓，是对对象的抽象，最能体现这一点的就是 接口。 我们讨论设计模式，都只是针对具备了抽象能力的语言，如c++,java,c#等，就是因为设计模式所研究的，正式如何合理的去抽象
- 声明接口的关键字是 interface
//关键就是抽象思维
public interface UserService {
//接口中的所有定义都是默认 public abstract
// 定义就是常量 public static final
int age = 99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void time();
}
//类可以实现接口 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 time() {
}
}
接口作用：
- 约束
- 定义一些方法，让不同的人实现
- public abstract
- public static final
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
17. N种内部类
- 内部类 就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类对A类来说就是内部类，而A类相对B类来说就是外部类了。
- 1.成员内部类
- 2.静态内部类
- 3.局部内部类
- 4.匿名内部类
- 成员内部类：
public class Outer {
private int id = 10;
private 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.Inner inner = outer.new Inner();
inner.in(); // 可调用
inner.getID(); // 10
}
}
- 静态内部类：
内部类加一个static关键字，即静态内部类；
静态内部类A就无法访问外部类B属性和方法，因为先实例化A，此时B没有实例化，访问不到。
- 匿名内部类：
一个java文件只能有一个public class类，可以有多个class类。
即可以在类的外面再写一个类；
匿名内部类即初始化类时没有用变量保存实例。
public class Test {
public static void main(String[] args) {
// 没有名字去初始化类,不用将实例保存到变量中
new Apple().eat(); // 1
//没有名字初始化接口，实现重写接口方法
new UserService(){
@Override
public void hello() {
System.out.println("2");
}
}.hello(); // 2
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
- 局部内部类：
也可以在类内部方法里再写一个类：
public class Outer {
// 局部内部类，类似局部变量
public void method(){
class Inner{
public void in(){
}
}
}
}
扫一扫
1867
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
