Java基础入门笔记05——面向对象,创建对象的内存分析,继承,封装,多态,object类,this&&super,方法重写,引用类型的强制转换,instanceof,抽象类,内部类,接口,异常。[通
大家好,又见面了,我是你们的朋友全栈君。
面向对象
- OOP——(Object-Oriented Programming)面向对象程序设计
- 面向过程——线性思维
- 面向对象——分类思维:大事化小,分而治之
面向对象的本质:以类的方式组织代码,以对象的形式组织(封装)数据
三大特征
- 封装
- 继承
- 多态
在生活认识角度:先有对象,后有类。
在代码运行角度:先有类,后有对象。类是对象的模板,对象是类的实例。
方法回顾
public class Demo01 {
//main 方法
public static void main(String[] args) {
}
//修饰符+返回值类型+方法名(参数列表){方法体 return}
public String sayHello(){
return "hello world";
}
public void hello(){
return;
//返回类型为void,可以不写return,也可以写return后面不跟东西
}
public int max(int a,int b){
return a>b?a:b;
}
}
异常抛出
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) {
}
//在方法上抛出异常给调用方法的人用throws
public void readFile(String file) throws IOException {
}
方法的调用
public class Demo02 {
public static void main(String[] args) {
}
//在一个类中为什么static方法不能调用普通方法?
//而普通方法可以调用static方法?
-----------------------------------------------
//因为static方法时间片非常短,它的加载与类的加载是同步的
//而非静态方法要等到类实例化后才会加载
public static void a(){
b();//报错
}
public void b(){
a();//通过
}
}
//此处仅作示例,两个方法互相调用会造成死锁
值传递和引用传递——java中只有值传递
- 值传递
public class Demo03 {
public static void main(String[] args) {
int a=1;
System.out.println(a);//输出1
Demo03.change(a);
System.out.println(a);
//此处为什么也是输出1?
//因为java是值传递,只是拷贝了一份传给方法
}
public static void change(int a){
a=10;
}
- 引用传递————本质还是值传递
//notes:
//一个类中只能有一个公共类public class且这个类名与文件名相同
//其他类不能加public
public class Demo04 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//此处输出null
Demo04.change(person);
System.out.println(person.name);//此处输出tim
}
public static void change(Person person){
person.name="tim";
}
}
class Person{
String name;
}
this关键字————this代表当前类或者当前对象(继承,多态)
类和对象的关系
使用new关键字创建对象时
- 分配内存空间
- 给创建好的对象进行默认的初始化(以及调用类的构造函数——构造器)
类的构造器 也称类的构造方法
- 必须和类名相同
- 必须没有返回类型,连void也不能写
- 如果程序没写构造方法,系统会默认生成无参构造方法;如果写了,会覆盖默认的,也就没有无参构造方法了。若还需要无参构造方法,要再重新写。(一般都会写两个构造,一个无参,一个有参)
构造器notes:
1.使用new关键字创建对象,该类必须要有构造器 2.构造器用来实例化属性(给属性赋初值)
IDEA快捷键 ——alt+insert生成构造器——constructor
public class Person {
String name;
int age;
public Person() {
//无参构造
}
public Person(String name) {
//有参构造
this.name = name;
}
public Person(String name,int age) {
//有参构造
this.name = name;
this.age=age;
}
}
//测试类
public class Application {
public static void main(String[] args) {
Person person = new Person("tim");
System.out.println(person.name);
}
}
创建对象时——内存分析
超棒,建议回看p65 https://www.bilibili.com/video/BV12J41137hu?p=65
对象的引用
- 对象是通过引用来操作的:栈指向堆(地址)
- 对象的属性——成员变量——一个意思
默认初始化:
整数:0 小数:0.0.
char:u0000
boolean: false
引用类型:null
三大特征:封装,继承,多态
封装
- 高内聚: 将内部数据操作细节自己完成,不允许外部干涉
- 低耦合: 减少外部联系(private) 仅暴露少量方法给外部使用(public)——get/set方法
属性私有——private,要想查看或修改仅能通过get/set
IDEA快捷键alt+insert——Getter and Setter
public class Person {
private String name;
private int age;
private char sex;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
//set方法中可以设置一些安全性检测
if(age>120||age<0){
this.age=-1;
}
else {
this.age = age;
}
}
}
public class Application {
public static void main(String[] args) {
Person xiaoming = new Person();
xiaoming.setName("小明");
System.out.println(xiaoming.getName());
xiaoming.setAge(135);
System.out.println(xiaoming.getAge());
}
}
封装的好处:
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口get/set
- 提高系统的可维护性
继承
- 关键字extends
- Java中类只有单继承,没有多继承
- 子类继承于父类,子类也可称作派生类
- 子类和父类间,从意义上应该具有“is a”的关系 [子类 is a 父类]
package oop.demo05;
public class Person {
public int money=10_0000_0000;
public void say(){
System.out.println("person类说了句话");
}
}
Student类继承了Person类
package oop.demo05;
public class Student extends Person{
}
package oop;
import oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
//student本来没有say方法,它的say()是继承于Person类的
System.out.println(student.money);
}
}
父类的私有属性,私有方法,无法被继承
修饰符的小结
- public
- protected
- default //默认
- private
object类
在java中所有类,都直接或者间接继承object类
- IDEA快捷键 ctrl+h打开继承关系树
- object类来自于java.lang(String也是这个包里的)
super关键字 ——-指代父类或父类对象
notes:
当父类的属性或方法被private修饰时,不能被继承
(也就是super.属性或super.方法()不能调父类的私有)
如果在父类中,写了有参构造方法,默认的无参构造方法就没了。此时子类在写super()去调用父类的无参构造就会报错了,所以一般情况:如果重写了父类的有参构造,一定要记得加上一个无参构造。
super小节
- 如果要使用super调用父类构造方法,必须在本类的构造方法的第一句
- super只能出现在子类的方法中或者子类构造方法中,且为第一句,如果在父类中使用super其实是指代object类
- super和this不能同时调用
super&&this
- super代表父类对象的引用,this代表本身这个对象
- this在没有继承时也能使用,super只有在继承条件下才能使用(在子类中使用)
- this()调用本类构造方法,super()调用父类的构造方法
方法重写
这里主要指:继承父类之后,对父类方法的重写
(方法的调用只和左边有关,打错字了[doge]) 解释:调用对象方法时,这个方法到底是用的父类方法,还是子类方法,主要看这个对象是以哪一个类定义出来的,看等号左边那个类。
和上上张图对比看两次的运行结果差异
小结:
- 重写需要有继承关系:子类重写父类的方法!(属性不能重写)
- 重写时:方法名必须相同,参数列表也必须相同(不要把方法重写和方法重载混淆)
- 修饰符问题:重写时,修饰符范围可以扩大,不能被缩小 public>protected>default>private
- 重写可能会抛出异常:重写时,异常的范围可以缩小,不能扩大 重写时,子类的方法名和父类必须要一致,方法体不同
为什么需要重写?
父类的功能,子类不一定需要,或者不满足,需要改写其他功能
IDEA快捷键Alt+Insert——Override Methods
多态
多态可以实现动态编译——增强程序的可扩展性
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student()
//new Person()
//但是一个对象可以指向的引用类型就不确定了
Student s1 = new Student();
Person s2 = new Student();//父类的引用指向子类
Object s3=new Student();
//对象能执行哪些方法,主要看左边的类型
//对象是执行父类的方法还是子类的方法?
//当两个类中都有同一个方法,则执行子类的
}
public class Person {
}
public class Student extends Person {
}
}
s1是Student类型,能调用自己和父类的方法
s2是Person类型,它指向子类Student,它不能调用子类独有的方法
子类可以用父类的方法,父类用子类的方法要进行强制转换 (此处需要强制将Person类转换为Student类)—-可能不对,还需要理解
多态notes:
- 多态是方法的多态,属性没有多态
- 两个类间有继承关系——可能出现类型转换异常——ClassCastException
- 多态存在的条件:1. 继承关系;2. 方法需要重写 (有个别方法不能重写,比如static方法属于类,不属于实例;final修饰的常量方法也不能被重写,private修饰的私有方法也不能重写)
- 父类可以引用指向子类对象 Father f1=new Son();
instanceof关键字
instanceof通过返回一个布尔值来指出,当前对象是否是一个特定类或者它的子类的一个实例
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
//===================================================================
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); 编译错误
// 因为person属于Person类,而Person类和String类没有继承关系
//===================================================================
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); // 编译错误
}
}
System.out.println( X instanceof Y )
编译能否通过? 取决于X,Y之间是否存在父子关系
得出结果? X是Y的子类型得到true,否则false
类型转换——引用类型
//继承关系
//Object>Person>Student
//Object>Person>Teacher Student类有一个go方法
public class Application {
public static void main(String[] args) {
//普通类型的转换
64->32 高转低(强制)————丢失精度
32->64 低转高(自动)
//引用类型的转换
//父类是更高级的类型,子类是更低级的
父->子 高转低(强制)
子->父 低转高(自动)————丢失子类特有的方法
//高 <---------------- 低 自动转换
Person obj=new Student();
// obj.go() 编译出错?因为obj已经被自动转换为了Person类型,丢失了go方法
// Person类型是Student类的父类,Person类并没有go()方法
// 所以如何让obj可以使用go方法?——把它强转为Student类型。
Student student1 = (Student) obj;
student1.go();//这两句也可以直接简化为 ((Student)obj)).go();
}
}
小结:
- 父类引用可以指向子类对象
- 若把子类对象转换为父类,即向上转型,自动(会丢失子类独有方法)
- 若把父类转化为子类,向下转型,强制
- 多态是为了方便方法的调用,减少重复的代码
static关键字
修饰属性——静态属性
public class Student {
private static int age; //静态变量——和类同时加载,存在于堆中的方法区中
private double score; //非静态变量——实例化对象后才存在
public static void main(String[] args) {
Student student = new Student();
System.out.println(Student.age); //通过类名访问静态变量
// System.out.println(Student.score); //报错,通过类名——不能访问非静态变量
// (因为静态变量和类同时创建,非静态变量要等到对象实例化时候才创建,所以非静态变量只能通过实例对象来调用)
System.out.println(student.age); //通过对象访问静态变量
System.out.println(student.score); //通过对象访问非静态变量
}
}
修饰方法——静态方法
public class Student {
//非静态方法
public void run(){
}
//静态方法
public static void go(){
}
public static void main(String[] args) {
run();//编译出错
go();//通过
// notes:
// 1.同理,静态方法和类同时创建,非静态方法要等到实例化后才能使用(new)
// 2.静态方法通过类名或者对象名都可以调用,非静态方法只能通过对象调用
// 3.此处比较特别,因为主函数和两个方法在同一个类中,所以不用前缀,也可以直接调用静态方法
// 4.在非静态方法中可以调用静态方法,然而在静态方法中不能调用非静态方法!
}
}
代码块
public class Person {
//匿名代码块——可用于赋初值
{
System.out.println("匿名代码块");
}
//静态代码块——类一加载就会同时执行静态代码块中的内容,且只执行一次
static {
System.out.println("静态代码块");
}
//构造方法
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
}
}
第一次执行: 输出: 静态代码块 匿名代码块 构造方法
====================================================== 第二次执行: 输出: 匿名代码块 构造方法
得出结论:类中模块的加载顺序——静态代码块,匿名代码块,构造方法 (且静态代码块只执行一次)
final关键字
final所修饰的类,无法被继承
抽象类——约束作用
abstract关键字
- abstract 修饰类——抽象类
- abstract 修饰方法——抽象方法——只有方法名没有方法体
抽象类被继承后,它原有的所有抽象方法,在子类中必须都要进行重写(实现)
(如果子类也是抽象类,则可以不重写,让子子类再去重写)
抽象类的特点
- 抽象类不能new出来,只能通过一个类去继承它,然后重写它的抽象方法进而由子类对象实现特定功能
- 抽象类中可以有正常方法
- 一个类中只要有抽象方法,就一定是抽象类,要用abstract修饰
Java类是单继承,但是接口可以实现“多继承” (此时继承也不叫继承了,叫实现——implements)
接口——实现多继承
普通类:只有普通方法 抽象类: 有普通方法和抽象方法 接口:只有抽象方法——无法直接创建对象
- 声明类的关键字——class
- 声明接口的关键字——interface
接口的本质是契约——把规定写出来,哪个类要使用他的抽象方法,就实现(implements)这个接口,然后将其抽象方法重写具体实现。 IDEA快捷键Alt+Insert——Override Methods
接口中定义的属性——默认为常量(public static final 默认,可以不写)
抽象思维,需要锻炼——架构师
interface小结:
- 接口的作用——约束
- 定义一些方法,让不同的类去实现
- 接口中的方法都是公开且抽象的—— public abstract 接口中的属性都是——public static final
- 接口不能被直接实例化(因为接口中没有构造方法)
- implements可以实现多个接口,且实现类必须要重写它所实现的所有接口中的所有方法
内部类
- 成员内部类
- 静态内部类——static
- 匿名内部类
- 局部内部类——可以写在方法里
异常
java.lang.Throwable
用户输入的内容格式不符合?要读取的文件不存在?内存满?被除数为0?文件找不到?网络连接失败?参数非法—–>Exception
三种异常
- 检查性异常
- 运行时异常
- 错误ERROR——由JVM生成并抛出,一般与编写者无关(栈溢出)
异常等级图——写在catch()中
异常处理机制
- 抛出异常——throw和throws
- 捕获异常
关键字——try,catch,finally,throw,throws
public class Test {
public static void main(String[] args) {
// try {A} catch (B b) {C} finally{D}
//A是监控区域,如果A中出现了B类异常(b是临时变量名),则可以忽视A中的问题,执行C;如果A中没有出现B类异常将不会执行C
//D中语句无论如何都会执行
int a=1;
int b=0;
try {
System.out.println(a/b); //除数等于0肯定是会出现异常的
}catch (ArithmeticException e){
//算术异常
System.out.println("出现ArithmeticException");
}finally{
System.out.println("运算结束");
}
}
}
运行结果:
出现ArithmeticException 运算结束
notes:
- try{}catch(){}是必须要的,finally可以不要
- finally一般用于善后工作,比如IO资源的关闭
可以并列捕获多个异常——把更高级的异常写在更下面 (否则编译无法通过,因为更高级的异常包含了低级异常)
public class Test {
public static void main(String[] args) {
int a=1;
int b=0;
try {
System.out.println(a/b);
}catch (Error e){
System.out.println("出现Error");
}catch (Exception e){
System.out.println("出现Exception");
}catch (Throwable e){
System.out.println("出现Throwable");
}finally{
System.out.println("运算结束");
}
}
}
对一行代码自动生成异常捕获代码 IDEA快捷键—— ctrl+alt+T
相比于自己手写,快捷键生成的异常处理块会多一句e.printStackTrace(),可以手动更改为其他处理语句,比如终止程序:System.exit()
关键字throw——主动抛出异常,在方法中使用,可以在方法中进行捕获
关键字throws——如果该方法处理不了这个异常,就只能在该方法上,往外抛异常(抛给调用方法的地方),然后在调用方法的代码块位置进行捕获。
自定义异常
自定义的异常需要继承Exception类(一般不需要自定义异常)
此处好像有一点点错误,右边框框里写的,此处是将异常抛给了调用者,所以好像应该去掉test()方法体内的那个主动抛出异常throw…下次看再分析
实践中的经验总结
- 处理运行时异常——>合理规避&&辅助try-catch处理
- 在多重catch块后面,可以加一个稍微高级的异常捕获如catch(Exception)来处理一些可能会被遗漏的异常
- 对于不确定的代码,也可以加上try-catch
- 尽量不要使用默认的异常处理方式(printStackTrace打印),而应该写一些实际的用于处理对应问题的代码
- finally代码块中主要是释放占用的资源
发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/168486.html原文链接:https://javaforall.cn
相关文章
- 女生学java_Java Server Pages
- java分布式事务框架_Java分布式事务,及解决方案
- arraylist扩容是创建新数组吗 java_arraylist扩容机制要怎么实现?arraylist怎么扩容…「建议收藏」
- java编译命令是什么_Java编译命令整理
- java从入门到精通_Java 入门到精通的过程
- Java编程基础(1)
- java集合类面试题_Java集合类相关面试题
- java启动器_JAVA基础:Java 启动器如何查找类
- java出现中文乱码_Java开发中中文乱码总结
- java实现ajax_Ajax&Java
- setproperty java_Java中System.setProperty()的用法
- java后台怎么解密md5,Java md5 密码加解密
- 零基础学Java(3)运算符
- Java Web(二)MyBatis
- 【JAVA面试必会】JMM高并发详解(java内存模型、JMM三大特征、volatile关键字 )「建议收藏」
- rtsp 获取视频流 java_Java获取rtsp视频流,实现rtsp流预览功能,并将视频流每帧保存成图片…
- java arraydeque poll,Java ArrayDeque「建议收藏」
- java webservice接口开发教程_JAVA入门教程
- java和vue开发的二手车小程序系统租车小程序系统
- 【Java 网络编程】TCP 传输机制 ( 数据拆分 | 排序 | 顺序发送 | 顺序组装 | 超时重发 )
- 详解Redis命令和键_动力节点Java学院整理
- Java 并发开发:Lock 框架详解编程语言
- Java使用log4j打印日志记录的5条规则详解编程语言
- 将任意自然数分解为质数的乘积(Java实现)详解编程语言
- Java isAlive()方法的作用
- 策略解决Redis中Java实现的过期策略(redisjava过期)
- 使用Java轻松导出MySQL数据(java导出mysql)
- Java配置Oracle实现稳定的跨平台数据库连接(java配置oracle)
- 异常Java程序捕获Oracle异常从失败中学习(java捕获oracle)
- 堆栈探索Java构建Oracle堆栈的可能性(java建oracle)
- java生成图片验证码示例程序