flsh

java基础

1.类与对象
*类是方法与属性的集合,是一种抽象的概念
*对象是对该类事物的具体体现形式,具体存在的个体
student stu1=new student(); student为类名 stu1为对象名=new student()为该类的构造方法

2.成员变量和局部变量
*成员变量:在类中方法外
*可以定义在任何位置,通常会定义在开头位置
*随着对象的创建而存在,随着对象的消息而消失
*有默认初始化值null
*局部变量:在方法定义中或者方法声明上
*随着方法的调用而存在,随着方法调用结束而结束
*没有默认初始化值,必须定义赋值,才能使用
*局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则
/*
class Student{
String name; 定义一个成员变量 [String]数据类型 name为变量名
void delimt(){ 编写一个方法
String name="小于" 定义一个局部变量 局部变量的优先级更高
this.name 如果要访问成员变量,[this].+变量名
}
}
*/

3.成员方法
*格式:
*[作用域] [final] 返回值类型 方法名(0-n个参数【形式参数】){
方法体
}
*void:表示没有返回值,不能返回任何值,但是可以return提前结束方法
*其他的数据类型:必须使用return返回1个值
成员方法不可以加:static关键字 若是加了static就叫做类方法
*重载方法:
*出现在同个类中
*与方法名一样
*参数不一样
*参数的数据类型不一样
*参数的个数不一样
*参数的数据类型的顺序不一样
/*
class Student{ 创建一个类
public final void delimt(){ 编写一个成员方法 [public]作用域 [final]唯一的 [void]数据类型 delimt方法名(){}
}
public final void delimt(String name){ 重载方法 (String name)为添加参数
}
}
*/

4.封装
*为什么使用封装
*如果直接给成员变量赋值,可能会赋一些非法的数据 stu.age=1000 学生的年龄是1000岁不可能
*所以采用一个专门的方法来管理相关属性的赋值,并实行校验
*方法
*如果不禁止成员变量的直接调用,则无法保证使用方法对属性赋值
*应强制使用方法进行赋值并校验
*如果只提供了set(赋值)的方法,那么外部没办法获取对象中的属性
*如果只提供了get(取值)的方法,那么外部没办法对对象中的属性进行赋值
*封装概述:
*隐藏对象的属性和实现细节,仅对外提供公共的访问方法
*对属性进行分装:将属性私有化(private),根据需要提供公共的访问方法(get/set)方法
*对方法进行封装:将方法私有化(private),提供公共的访问方法
*将不需要对外提供的内容都隐藏起来
*把属性隐藏,提供公共的访问方法
*好处:
*隐藏实现细节,提供公共的访问方式
*提高了代码的复用性
*提高安全性

5.构造方法
*构造方法的方法名与类名一样(包括大小写)
*构造方法没有返回值类型
*一般用void表示无返回值
*构造方法是一个特殊的方法,用于实例化对象所需要调用的方法
*每个类至少有一个构造方法,如果没有明确写出构造方法,系统就会默认提供一个无参构造构造方法
*如果我们明确定义了构造方法,那么系统就不再提供默认构造方法
*构造方法可以重载s
*重载
*在同一个类中
*方法名一样
*参数的类型不一样
*参数的个数不一样
*参数的类型的顺序不一样
*需要成员变量赋初值,需要做一些初始化操作
*每一个类都有一个构造方法,说明每一个类都可以实例化
*如果要防止类被实例化:将构造方法进行封装(private)
*在单例模式中可以使用
*静态工厂方法中可以使用(static)

6.static关键字
*可以用于修饰
成员变量---->类变量(静态成员变量)
成员方法---->类方法(静态方法)
*内部类
*随着类的加载而加载
*类什么时候被加载
*当类第一次使用时就会加载这个类
*加载类实际上是由JAM调用类加载把.class文件加载在内存中
*存放在方法区中
*当类被加载时,类变量就会被加载
*方法区:存储程序执行过程中只有一个变量
*本地方法区:存储的不是Java代码,而是存放Java之外的东西,比如C语言的代码
*优先于对象存在,static修饰的东西与对象无关
*被类的所有对象共享,可以通过对象来调用static修饰的东西
*可以通过类名直接调用
*静态成员变量(类变量)
*被所有的对象所共享
*静态成员方法(类方法)
*被所有对象所共享,可以通过对象来调用
*类方法中不能使用this关键字,this关键字代码1个特定的对象
*类方法只能访问类变量或方法

7.this关键字
*this是一个关键字
*this表示当前对象,用于调用对象的成员变量与成员方法(比如set方法)
public void setName(String name){
this.name=name;
}
*哪个对象调用了成员方法,那么this就代表哪个对象
*this如何表示当前对象
*Java的对象在调用方法时,会给方法传入1个我们看不到的参数(默认)
*这个参数的位置在方法参加中的第一个,参数名可以理解为(this),this接收的实参为调用这个方法的对象
*Java中调用类方法时,不会传入默认的参数,所以不能使用this关键字

8.继承(extends)
*继承的优点
*多个类存在相同属性和行为,将这些相同的内容提取到独立的一个类中,实现多个类无需重复定义这些属性与方法,通过继承来实现
*Java中的类是单继承的,但接口可以多继承,类也可以实现多个接口
*java中的类是单继承的
*如果一个类继承了两个类,但是这两个类中有相同的方法,那么子类调用,无法确定应该调用哪个方法。
*接口可以多继承
*因为接口只有抽象方法,具体方法只能由实现接口的类实现,在调用的时候始终只会调用实现类(也就是子类覆盖的方法)的方法(不存在歧义),
因此即使继承的两个接口中的方法名是一样的,最终调用的时候也都是调用实现类中的那个方法,不会产生歧义。
*类也可以实现多个接口
*一个子类可以同时实现多个接口,那么实际上就摆脱了Java中的类单继承局限。
*object类是java中所有类的直接或间接父类
*一个类如果没用明确的继承一个外类,那么这个类默认继承object类。

9.作用域修饰符
*主要用于控制属性与方法的访问权限
*体现在:同一个类中,同一个包中,不同包,继承关系
*public(公有) protected(保护) private(私有) default (默认)
*权限表
同一个类 同一个类 继承 不同包
public | ✔ | ✔ | ✔ | ✔ |
protected | ✔ | ✔ | ✔ | |
default | ✔ | ✔ | | |
private | ✔ | | | |


10.重写
*子类中出更与父类一样的方法,称为方法重写(方法覆盖,方法复写)
*只有方法重写,没有属性重写
*方法重写特点
*在子类中,方法名一样
*参数一样
*参数类型一样
*参数个数一样
*参数类型的顺序一样
*返回值类型一样
*重写时,子类的作用域不能小于父类的作用域
* @override:用于标记方法为重写方法,如果不是重写方法会报编译异常
class people //父类people class student extends people //子类student继承父类people
{ { @override
String name; public void study() //重写study方法
int age; {
public void study() //方法study System.out.println("我是学生");
{ } }
System.out.println("我是人类");
} }

*方法重载
*参数类型不一样
*参数个数不一样
*参数类型的顺序不一样
*与返回值类型无关
class teacher extends people //子类student继承父类people
{
public void study(int age) //重写study方法
{
System.out.println("我是老师,今年"+age+"岁");
} }

11.final关键字
*final:终态,不能改变(独一无二的)
*修饰局部变量:局部变量
*修饰成员变量::成员常量
*修饰方法:终态方法,方法的最终形态,不能被重写
*修饰类:终态类,类的最终形态,不能被继承
*编写String类的子类,然后增加***功能
*static final 属性/方法:常量/类终态方法

12.继承的优缺点
*继承时:把公共的属性与行为提取到父类中,子类不用重复的编写这些属性与方法
*优点
*提高代码的反复性,一段代码,多次使用2021/6/30
*提高代码的可维护性
*使用多态的前提
*缺点
*类与类之间产生关系,提高代码的耦合性
*在项目开发中:高内聚,低耦合
*内聚:在一个类中能够独立完成一些功能
*耦合:需要其它的类配合才能完成一些功能
13.多态
(1)多态概述
*字面理解:多种状态
*某一个对象在不同条件下表现出不同的状态
*使用多态的条件
*继承关系/接口关系
*子类重写父类方法
*父类引用子类的对象
*当使用父类的引用来调用重写的方法时,调用到子类的方法
*重写
*子类中出现与父类一样的方法定义
*方法名一样
*方法的参数一样
*返回值类型一样
*子类中定义的方法作用域应不小于父类中定义的方法的作用域

(2)方法调用
*子类引用子类对象 // student stu=new student();
父类有,子类也有:执行子类方法
父类有,子类没有:执行父类方法
父类没有,子类有:执行子类方法
*父类引用子类对象 // person per=new student();
父类有,子类也有:执行子类方法
父类有,子类没有:执行父类方法
父类没有,子类有:报编译异常
*父类描述的范围比子类的大,范围大的可以引用范围小的
*范围小的描述范围大的,强制类型转换 //person per=new student();
//student stu=(student) per;
(3)属性调用
*子类引用子类的对象
父类有,子类也有:调用子类属性
父类有,子类没有:调用父类属性
父类没有,子类有:调用子类属性
*父类引用子类的对象
父类有,子类也有:调用父类属性
父类有,子类没有:调用父类属性
父类没有,子类有:报编译异常

(4)父类域子类的类型转换
*父类可以直接引用子类的对象
*子类如果要引用父类的对象,必须进行强制类型转换
*被转换的对象属于子类的对象
*强制类型转换时,要注意类型的匹配
*对象 instanceof 类:判断对象不是类的一个对象
*per instanceof Student
*在参数传值的时候,会使用数据类型最匹配的方法
*匹配的时引用的类型,而不是对象的实际类型

(5)多态的优缺点
*优点
*提高代码的可维护性
*提高代码的可扩展性
*缺点
*只能调用父类中有定义的方法,不能调用子类特有的方法
*如果要调用子类特有的方法,必需通过强制类型转换来实现
*使用instanceof关键字来判断类型

14.面向对象小结
*对象用于描述现实世界中的事物
*把一系列相似的对象进行抽取-->得到类
*使用类的时候,需要先对类进行实例化,实例化的结果是一个对象
*对象具有属性与方法-->对相应的成员变量与成员方法
*封装:类的一些成员变量与成员方法不希望对外提供方法,只在类的内部使用
*子类只需要继承父类,就能得到父类中定义的属性与方法(extends关键字)
*多态,用父类引用子类对象,通过父类的引用可以调用到子类的方法
*前提:子类重写父类的方法

15.抽象类
(1)抽象简介
*在使用面向对象思想对问题进行分析处理过程中,如果得到一系列看上去不一样,但本质上相同的具体概念,通常会采用抽象类来处理
*抽象是一种功能不完全的类,不能被实例化
*在定义类是,通过abstract关键字来修饰,被修饰的类就是抽象类
*抽象类的大部分用法跟非抽象类是一样的
*抽象类一样有属性、方法、构造方法
(2)属性
*属性:使用方式与非抽象类一样
(3)构造方法
*构造方法:实例化对象时调用
*抽象类不能实例化
*抽象类中的构造方法只能被子类调用 //super(***);
(4)方法
*抽象类中包含两种方法
*抽象方法:没有方法体的方法,在定义方法的时候,使用abstract关键字进行修饰
* public abstract void eat();
*抽象方法只能出现在抽象类中,非抽象类中不能定义抽象方法
*子类(非抽象类)必需重写父类中定义的抽象方法
*子类(抽象类),可以继承父类中定义的抽象方法,可以不用重写,可以重写
*非抽象方法
*使用方式与普通的类中的方法一样
*子类可以重写,也可以不重写
(5)非法关键字组合
*abstract:
*修饰类:只能做为父类
*修饰方法:必须被重写
*final:
*修饰类:最终类,不能别继承,不能作为父类
*修饰方法:最终方法,不能被重写
*private
*只能在类内部使用
*static
*修饰方法:类方法,随着类的加载而加载

16.接口
(1)接口概述
*接口本身不具备任何功能,只是定义了相关的一些规范,接口中所有的功能都由实现类来提供
*定义类时,使用class关键字:定义接口使用interface关键字
*接口本身不具备任何功能,所以不能被实例化,也没有构造方法
*多借口,一个类可以多个接口
*public class student implements A,B,C;
*接口之间时可以继承,多继承
*public interface C extends A,B;

(2)属性
*类/抽象类
*成员变量
*成员常量:如果没有特殊需求,通常使用类常量
*类变量(静态常量) //常量:在程序中固定不变的值,是不能改变的数据
*类常量(静态变量)
*接口:只能定义类常量
*如果没有使用public、static、final修饰,默认会帮助我们添加
*只能使用public做为作用域
*接口是定义常量最好的地方
(3)方法
*非抽象类中,只能定义非抽象方法
*抽象类中,可以定义抽象方法,可以定义非抽象方法
*接口中,只能定义抽象方法
*自动加上:abstract关键字
*只能使用public,如果不写,会自动加上
*实现类(非抽象类),必须实现接口中定义的所有方法(重写)
*public class student implements person{ }
*person是接口
*student是person接口的实现类
*实现类(抽象类),可以实现接口中的方法,也可以不实现接口中的方法
*抽象类本身就可以有抽象方法
(4)多态
*接口可以更好的实现多态
*接口理解成为父类
*实现类理解成为子类
*用父类引用子类的对象,父类的引用可以调用子类中重写父类的方法
*用接口引用实现类的对象,接口的引用可以调用导实现类中的实现的接口中的方法
(5)默认方法
*JDK8.0新特性,允许接口中定义默认方法
*原来:接口中只能定义抽象方法,不能写方法体
*现在:接口中可以在默认方法中写方法体
*默认方法:用default来修饰方法
*public default void say() { **** }
(6)接口的优点
*一个类可以有多个接口
*继承:只能有一个父类
*更容易搭建程序框架
*设计与具体的实现完全分离
*更容易更换实现类
*更自然的使用多态

posted on 2023-09-15 07:47  小鱼洗香香  阅读(14)  评论(0编辑  收藏  举报

导航