050_面向对象

清风(学习-踏实) 2020-11-09 10:50:00
面向对象 对象 面向 050_


面向对象

https://www.bilibili.com/video/BV12J41137hu/?p=60

面向对象定义

  1. 面向对象编程 OOP Object Oriented Programming
  2. 面向对象编程的本质:以类的方式组织代码,以对象的方式组织(封装)数据。
  3. 抽象
  4. 三大特性
    1. 封装
    2. 继承
    3. 多态

类与对象的关系

  1. 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。
  2. 对象是抽象概念的具体实例。

创建与初始化对象

使用new关键字创建对象。

  1. 使用new关键字创建对象的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
  2. 类中的构造器也成为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点。
    1. 必须和类的名字相同。
    2. 必须没有返回类型,也不能写void。
  3. 使用new关键字,本质是在调用构造器,初始化对象的值。
  4. 默认会存在隐式无参构造器。
  5. 一旦写了有参构造器,隐式构造器就不存在了,必须也写无参构造器,否则无参new会报错。
  6. idea中Alt+insert,生成构造器。
package com.oop.demo01;
public class Person {
private String name;
private int age;
}
package com.oop.demo01;
public class Person {
private String name;
private int age;
public Person() {
}
}

创建对象内存分析。

  1. 对象是通过引用来操作的,栈-->堆。

image.png

属性:字段 Field 成员变量 默认初始化

  1. 数字: 0 0.0
  2. char:u0000
  3. boolean:false
  4. 引用:null

  1. 静态的属性 属性
  2. 动态的行为 方法

封装

高内聚低耦合

  1. 高内聚就是类的内部数据操作细节自己完成,不允许外部干涉。
  2. 低耦合就是仅暴露少量的方法给外部使用。
  3. 属性私有 get/set。

封装的意义

  1. 提高程序的安全性,保护数据。
  2. 隐藏代码的实现细节。
  3. 统一接口。
  4. 提高程序可维护性。

继承

  1. Java中类只有单继承,没有多继承。
  2. 继承是类和类之间的一种关系。
  3. 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。
  4. 子类继承父类,使用关键字extends来表示。
  5. 子类和父类之间,从意义上讲应该具有"is a"的关系。
package com.oop.demo01;
public class Student extends Person {
private int grade;
}
package com.oop.demo01;
public class Student extends Person {
private int grade;
public Student() {
}
}

Object

  1. 在Java中,所有的类都默认之间或间接继承Object。

image.png

super

  1. super调用父类的属性和方法,只能出现在子类的方法或构造方法中。
  2. super()调用父类的构造方法,必须在构造方法的第一行。
  3. super()和this()不能同时调用构造方法。
  4. this,本身对象的引用。
  5. super,父类对象的引用。
public class Student extends Person {
private int grade;
public Student() {}
public Student(int grade) {
super();
this.grade = grade;
}
public Student(String name, int age, int grade) {
super(name, age);
this.grade = grade;
}
}

方法重写

  1. 需要有继承关系,子类重写父类的方法。
  2. 重写不能是静态方法,静态方法随类加载。
  3. 方法名必须相同且参数列表必须相同。
  4. 修饰符可以扩大,不能缩小 。public>protected>default>private
  5. 抛出的异常可以缩小,不能扩大。
package com.oop.demo01;
public class A {
public void test() {
System.out.println("A=>test");
}
}
package com.oop.demo01;
public class B extends A {
@Override
public void test() {
System.out.println("B=>test");
}
}
B=>test
B=>test

多态

  1. 多态即同一方法可以根据调用对象的不同采用多种不同的行为方式。
  2. 一个对象的实际类型是确定的,但可以指向对象的引用类型有很多(本身,父类,父类的父类...)。
  3. 父类的引用指向子类。
  4. 对象能执行那些方法,看对象的引用类型。
  5. 子类重写方法后,父类引用和子类引用都执行子类方法。
//对象能执行那些方法,看对象的引用类型。
//父类引用a只能调父类A的方法,子类引用b可以调父类A和子类B的方法,子类引用c可以调父类A和子类C的方法。
//如果子类重写父类方法,都执行子类方法。
A a = new B();
B b = new B();
A c = new C();

多态存在的条件

  1. 有继承关系。
  2. 子类重写父类的方法。
  3. 父类引用指向子类对象。

不能多态的方法

  1. static 方法,属于类,他不属于实例。
  2. final
  3. private方法。

instanceof

  1. 判断对象类型。
  2. 对象是否是类的实例或类的子类的实例或类的子类的子类...的实例。
public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Teacher
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);//编译报错
}

引用类型转换

  1. 引用类型之间的转换:父类 子类
  2. 子类转父类自动转换。Object object = person;
  3. 父类转子类强制转换。Student b = (Student) person;
  4. 子类转为父类,只能调用父类的方法。
Person person = new Student();
Object object = person;
Student b = (Student) person;

static

  1. 静态变量:static修饰的变量,也叫类变量。
static int age;
//静态变量的调用
System.out.println(Person.age);
  1. 静态方法:static修饰的方法。
    1. 静态方法不能调用非静态方法,因为静态方法随类加载,静态方法加载时非静态方法还没有加载。
    2. 非静态方法可以调用静态方法。
    3. 静态方法不能调用非静态变量。
    4. 非静态方法可以调用静态变量。
public static void test(){}
  1. 静态代码块:类加载时执行一次。
package com.oop.demo01;
public class Demo {
//执行顺序:2 一般用来赋初始值
{
System.out.println("匿名代码块");
}
//执行顺序:1 只执行一次
static {
System.out.println("静态代码块");
}
//执行顺序:3
public Demo() {
System.out.println("无参构造方法");
}
public static void main(String[] args) {
Demo demo1 = new Demo();
System.out.println("=======================");
Demo demo2 = new Demo();
}
}
静态代码块
匿名代码块
无参构造方法
=======================
匿名代码块
无参构造方法
  1. 静态导入包
import static java.lang.Math.random;

抽象类

  1. abstract修饰方法,该方法就是抽象方法。
  2. abstract修饰类,该类就是抽象类。
  3. 抽象类中可以没有抽象方法,但有抽象方法的类一定是抽象类。
  4. 抽象类中可以有普通方法。
  5. 抽象类有默认的无参构造方法。
  6. 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
  7. 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
  8. 子类继承抽象类,必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
package com.oop.demo02;
//抽象类
public abstract class Action {
//抽象方法
public abstract void test();
}
package com.oop.demo02;
//继承了抽象类的正常类,必须实现抽象类的所有没有实现的抽象方法
//继承了抽象类的抽象类,可以不实现抽象类的抽象方法
public class ActionA extends Action {
@Override
public void test() {
}
}

接口

  1. 普通类:只有具体的实现。
  2. 抽象类:具体实现和规范(抽象方法)都有。
  3. 接口:只有规范。
  4. 接口不能被实例化,因为接口中没有构造方法。
  5. 接口中的所有属性都是常量,默认 public static final
  6. 接口中的所有方法其实都是抽象的,默认 public abstract
  7. 单继承,多实现:可以实现多个接口,只能继承一个父类。
  8. 实现了接口的类,就必须重写接口中的所有方法。
package com.oop.demo03;
//接口,接口都需要有实现类
public interface UserService {
//接口中的所有属性都是常量,默认 public static final
int age = 9999;
//接口中的所有方法其实都是抽象的,默认 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package com.oop.demo03;
public interface TimerService {
}
package com.oop.demo03;
//单继承,多实现
//可以实现多个接口,只能继承一个父类
//实现了接口的类,就必须重写接口中的所有方法
//实现类
public class UserServiceImpl implements UserService,TimerService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}

内部类

内部类就是在一个类的内部再定义一个类,比如,A类在定义一个B类,那么B类相对A类来说就成为内部类,而A类相对B类就是外部类。

成员内部类

  1. 成员内部类可以使用外部类的所有非静态属性和方法,包括私有的。
package com.oop.demo04;
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);
out();
}
}
}
package com.oop;
import com.oop.demo04.Outer;
//一个项目应该只有一个main方法
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
// outer.out();
//通过外部类实例来实例化内部类,内部类必须是public
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
}
}

静态内部类

  1. 静态内部类可以使用外部类的静态属性和静态方法,不能使用非静态属性和方法。
package com.oop.demo04;
public class Outer {
private static int id = 10;
private static void out() {
System.out.println("这是外部类的方法");
}
//静态内部类
public static class Inner {
public void in() {
System.out.println("这是内部类的方法");
}
//内部类可以使用外部类的私有属性和方法
public void getId() {
System.out.println("内部类输出外部类私有属性:" + id);
out();
}
}
}

局部内部类

package com.oop.demo04;
public class Outer {
public void out() {
//局部内部类
class Inner {
}
System.out.println("这是外部类的方法");
}
}

匿名内部类

版权声明
本文为[清风(学习-踏实)]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/wl3pb/p/13947081.html

  1. 【计算机网络 12(1),尚学堂马士兵Java视频教程
  2. 【程序猿历程,史上最全的Java面试题集锦在这里
  3. 【程序猿历程(1),Javaweb视频教程百度云
  4. Notes on MySQL 45 lectures (1-7)
  5. [computer network 12 (1), Shang Xuetang Ma soldier java video tutorial
  6. The most complete collection of Java interview questions in history is here
  7. [process of program ape (1), JavaWeb video tutorial, baidu cloud
  8. Notes on MySQL 45 lectures (1-7)
  9. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  10. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  11. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  12. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  13. 【递归,Java传智播客笔记
  14. [recursion, Java intelligence podcast notes
  15. [adhere to painting for 386 days] the beginning of spring of 24 solar terms
  16. K8S系列第八篇(Service、EndPoints以及高可用kubeadm部署)
  17. K8s Series Part 8 (service, endpoints and high availability kubeadm deployment)
  18. 【重识 HTML (3),350道Java面试真题分享
  19. 【重识 HTML (2),Java并发编程必会的多线程你竟然还不会
  20. 【重识 HTML (1),二本Java小菜鸟4面字节跳动被秒成渣渣
  21. [re recognize HTML (3) and share 350 real Java interview questions
  22. [re recognize HTML (2). Multithreading is a must for Java Concurrent Programming. How dare you not
  23. [re recognize HTML (1), two Java rookies' 4-sided bytes beat and become slag in seconds
  24. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  25. RPC 1: how to develop RPC framework from scratch
  26. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  27. RPC 1: how to develop RPC framework from scratch
  28. 一次性捋清楚吧,对乱糟糟的,Spring事务扩展机制
  29. 一文彻底弄懂如何选择抽象类还是接口,连续四年百度Java岗必问面试题
  30. Redis常用命令
  31. 一双拖鞋引发的血案,狂神说Java系列笔记
  32. 一、mysql基础安装
  33. 一位程序员的独白:尽管我一生坎坷,Java框架面试基础
  34. Clear it all at once. For the messy, spring transaction extension mechanism
  35. A thorough understanding of how to choose abstract classes or interfaces, baidu Java post must ask interview questions for four consecutive years
  36. Redis common commands
  37. A pair of slippers triggered the murder, crazy God said java series notes
  38. 1、 MySQL basic installation
  39. Monologue of a programmer: despite my ups and downs in my life, Java framework is the foundation of interview
  40. 【大厂面试】三面三问Spring循环依赖,请一定要把这篇看完(建议收藏)
  41. 一线互联网企业中,springboot入门项目
  42. 一篇文带你入门SSM框架Spring开发,帮你快速拿Offer
  43. 【面试资料】Java全集、微服务、大数据、数据结构与算法、机器学习知识最全总结,283页pdf
  44. 【leetcode刷题】24.数组中重复的数字——Java版
  45. 【leetcode刷题】23.对称二叉树——Java版
  46. 【leetcode刷题】22.二叉树的中序遍历——Java版
  47. 【leetcode刷题】21.三数之和——Java版
  48. 【leetcode刷题】20.最长回文子串——Java版
  49. 【leetcode刷题】19.回文链表——Java版
  50. 【leetcode刷题】18.反转链表——Java版
  51. 【leetcode刷题】17.相交链表——Java&python版
  52. 【leetcode刷题】16.环形链表——Java版
  53. 【leetcode刷题】15.汉明距离——Java版
  54. 【leetcode刷题】14.找到所有数组中消失的数字——Java版
  55. 【leetcode刷题】13.比特位计数——Java版
  56. oracle控制用户权限命令
  57. 三年Java开发,继阿里,鲁班二期Java架构师
  58. Oracle必须要启动的服务
  59. 万字长文!深入剖析HashMap,Java基础笔试题大全带答案
  60. 一问Kafka就心慌?我却凭着这份,图灵学院vip课程百度云