前面内容请见:
JAVA基础–JAVA SE(知识点总结 Ⅰ )
JAVA基础–JAVA SE(知识点总结 Ⅱ )
JAVA基础–JAVA SE(知识点总结 Ⅲ )
以下是我们今天的内容:
面向对象
1.局部变量和成员变量的区别
-
书写位置不同:
-
成员变量:在类中,方法外 -
局部变量:在方法定义中,或者方法声明上
-
-
内置中的位置不同
-
成员变量:堆内存中,和对象有关系 -
局部变量:栈内存中,和方法有关系
-
-
生命周期不同:
-
成员变量:随着对象的创建而存在,随着对象的创建完毕后,等待jvm的垃圾回收器(GC)空闲的时候回收而消失 -
局部变量:随着方法的调用而存在,随着方法调用结束而消失
-
-
初始化值不同:
-
成员变量:是可以不初始化的,需要通过对象名来赋值,存在默认初始化 -
局部变量:必须在使用之前初始化,否则报错;
-
-
什么时候把一个变量定义为成员变量?
-
如果一个类能够描述这个事物的属性,必须为定义成员变量 -
否则,都定义为局部变量
-
//定义一个类 Demo
class Demo{
//成员变量:类中方法外
public int num ;
public void show(String a){
//局部变量
int x = 5 ; //必须使用之前初始化,否则编译会报错--报错信息Variable 'x' might not have been initialized
System.out.println(a+x);
}
}
//测试类
public class VariableDemo {
public static void main(String[] args) {
//要去访问Demo类中num变量
Demo d = new Demo() ;
System.out.println(d.num); //对象名.成员变量名;
d.show("胡歌");
}
}
2.this关键字
-
代表当前类对象的地址值引用
-
目的:就是为了区分局部变量隐藏了成员变量,加入this可以区分
-
-
格式
- this.成员变量名 = 局部变量名 ;
/*手机有品牌(brand),价格,颜色,内存等属性,手机可以打电话,发短信,打游戏等行为,
请使用面向对象的方式描述手机并且进行测试*/
public class Phone {
private String brand;
private double price;
private String color;
private String memory;
public void setBrand(String brand){
this.brand = brand;
}
public void setPrice(double price){
this.price = price;
}
public void setColor(String color){
this.color = color;
}
public void setMemory(String memory){
this.memory = memory;
}
public String getBrand(){
return brand;
}
public double getPrice(){
return price;
}
public String getColor(){
return color;
}
public String getMemory(){
return memory;
}
public void callPhone(String toName){
System.out.println("在用" + brand + "," + "给" + toName + "打电话");
}
public void sendMsg(String toName){
System.out.println("在用" + brand + "," + "给" + toName + "发短信");
}
public void playGame(String toGame){
System.out.println("在用" + brand + "," + "玩" + toGame);
}
}
3.匿名对象
-
匿名对象:毋庸置疑,没有名字的对象;
-
匿名对象的格式
- new 类名();
-
优点
- 直接在堆内存开辟空间,创建完毕之后,没有栈内存指向,所以使用完毕,立即被GC(垃圾回收器回收)
- 一般情况:匿名对象使用一次即可,这样不需要过多的去开辟堆内存空间,直接被回收
- 匿名对象可以作为参数传递
- 直接在堆内存开辟空间,创建完毕之后,没有栈内存指向,所以使用完毕,立即被GC(垃圾回收器回收)
-
注意
- 方法的形式参数如果是基本类型,调用该方法的时候,实际参数只需要传递对应的数据值即可
- 方法的形式参数如果是引用类型:数组,类,接口,实际参数在进行传递时需要传递,当前数组对象 /类的对象/接口的对象
方法形式参数如果是一个类(引用类型),当调用该方法时,实际参数应当如何传递
如果方法的形式参数是类,实际参数传递时,需要传递的是当前类的具体类对象
- 参数名.study(): ----参数名一定要是空间地址值,则需要创建具体的学生对象
//定义一个类Demo class Demo{ //成员方法 public int add(int a,int b){ //方法的形式参数是基本类型 return a+ b ; } } //定义一个学生类 class Student{ public void study(){ System.out.println("好好学习,天天向上!"); } } //定义一个StudentDemo类对象 class StudentDemo{ //成员方法method public void method(Student student){ //引用类型:数组,类或者接口 方法形式参数类型:Student类型 //参数名.study(): ---参数名一定要是空间地址值,则需要创建具体的学生对象 student.study() ; } } //测试类 public class StudentTest { public static void main(String[] args) { //1.方法的形式参数是基本类型: Demo d = new Demo() ; int result = d.add(15,15) ; System.out.println("结果为:"+result); System.out.println("----------------------------------------------") ; //2.要访问StudentDemo类中的method方法? //创建StudentDemo类的对象 //类名 对象名 = new 类名() ; StudentDemo sd = new StudentDemo() ; //创建Student类具体对象 Student student = new Student() ; sd.method(student) ;//方法的形式参数Student类型,所有需要将Student具体对象创建出来才能调用 //链式编程,匿名对象作为参数(一般不推荐) new StudentDemo().method(new Student()); } }
4.类的构造方法
-
什么是类的构造方法 ----> 一个比较特殊的方法
- 方法名和类名相同
- 没有void
- 构造方法可以重载
-
分类
-
无参构造方法(构造器)
public 方法名(){ }注意:
-
方法名与类名一致
-
没写构造方法是,系统默认为无参构造方法, 但是当如果提供有参构造方法时,系统就不会在提供无参构造方法
-
-
有参构造方法(构造器)
public 方法名(参数类型 参数名,...){ }注意:
- 方法名与类名一致
-
-
构造方法的目的
- 为了类的成员相关的数据,进行初始化
- 系统默认初始化
- 显示初始化
- 为了类的成员相关的数据,进行初始化
-
一个标准类(JavaBean)的写法:
-
成员变量私有化 -
提供对外的公共访问方法,setXXX()/getXXX() -
提供无参构造/ 有参构造方法 (根据需求进行判断)
-
/*学生有姓名,年龄,性别属性,行为有学习,睡觉以及玩游戏的行为,
睡觉的行为,没有返回值类型; 玩游戏的行为:有一个字符串String类型的参数 gameName
请使用面向对象方式书写学生类并且进行测试(使用标准类完成并进行测试)*/
public class Student {
String name;
int age;
String sex;
//无参构造方法
public Student() {
}
//有参构造方法
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void study(){
System.out.println(name + "正在学习中......");
}
public void sleep(){
System.out.println(name + "正在睡觉......");
}
//玩游戏的行为:有一个字符串String类型的参数 gameName
public void game(String gameName){
System.out.println(gameName + "正在玩游戏......");
}
}
//测试类
public class StudentTest {
public static void main(String[] args) {
//无参构造方法
Student student = new Student();
student.setName("天天");
student.setAge(25);
student.setSex("女");
System.out.println("姓名:" + student.getName() + "\n" + "年龄:" + student.getAge() + "\n" +"性别:" +
student.getSex());
student.study();
student.sleep();
student.game("DOTA");
System.out.println("---------------------------------------------");
//有参构造方法
Student student1 = new Student("向向",25,"男");
System.out.println("姓名:" + student1.getName() + "\n" + "年龄:" + student1.getAge() + "\n" +"性别:" +
student1.getSex());
student1.study();
student1.sleep();
student1.game("DOTA");
}
}
5.static关键字
- 特点
- 被静态修饰的,随着类的加载而加载,优先于对象存在
- 不能和this共存
- 本身含义就是共享,共用,可以多个对象共享共用
- 被静态修饰的成员变量或者成员方法,叫做静态变量或者静态方法
public class Person {
//属性:姓名,年龄和国籍,先不用私有
String name ; //姓名
int age ; //年龄
static String country ;// 国籍
//永远给出无参构造方法
public Person(){}
//给出有参构造方法 ---带两个参数
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
//带三个参的构造方法
public Person(String name,int age,String country){
this.name = name ;
this.age = age ;
this.country = country ;
}
//show方法,展示这个人具体信息
public void show(){
System.out.println("这个人姓名是:"+name+",年龄是:"+age+",所在的国籍是:"+country);
}
}
//测试类
public class PersonTest {
public static void main(String[] args) {
//测试
//描述 古代四大美女
Person p1 = new Person("貂蝉",25,"中国") ;
p1.show();
Person p2 = new Person("王昭君",21);
p2.show();
Person p3 = new Person("西施",22);
p3.show();
Person p4 = new Person("杨玉环",27); //只有第一个输入"中国",但后面3个同样输出"中国"
p4.show();
}
}
-
访问的方式:
-
可以使用对象名来访问,但是,对于系统来说(jvm)对静态的东西:变量/方法,都是通过类名直接访问 * 类名.变量名; * 类名.方法名();
-
-
静态的使用场景适用于范围:
-
简单记忆:静态只能用于访问静态 * 静态方法中只能访问静态变量 * 静态方法只能调用静态方法 * 非静态方法皆可以访问静态的东西也可以访问非静态的东西
-
public class ArrayTool {
//提供一个私有的构造方法,为了外界不能直接new
private ArrayTool(){}
public static void printArray(int[] arr){ //形式参数---引用类型,数组类型,需要传递这个数组的对象
System.out.print("[");
for(int x = 0 ; x <arr.length ; x ++){
//如果x角标取到最大索引值
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else{
System.out.print(arr[x]+", ");
}
}
}
}
//测试类
public class ArrayTest {
public static void main(String[] args) { //静态只能访问静态
//数组,静态初始化了
int[] arr = {65,13,24,97,78} ;
//新的访问:使用工具类名.静态方法名()
//遍历
ArrayTool.printArray(arr) ;
}
}
6.javadoc注释文档(补充)
- 对ArrayTool.java文件产生一个文档说明书 ----> 类似于API(Application Programming Interface:应用程序接口文档)
-
使用jdk安装目录里面的bin里面: javadoc.exe 指令,产生文档说书的指令 -
将ArrayTool这个java文件代码复制到本地某个磁盘上,类名和文件名称一致(先不要把package复制上去) -
打开dos窗口,进入到这个java文件的路径下(保证访问权限足够大:public) -
用javadoc -d 目录名称 -author -version ArrayTool.java(java源文件带后缀) 产生文档说明书
-
/**
*ArrayTool类是针对数组操作的工具类,里面包含了数组的遍历功能,求数组最值问题,
* 获取数组的元素第一次出现索引值,冒泡排序等提供很多功能;
* @author In-Deep
* @version V8.0
*/
public class ArrayTool {
private ArrayTool(){}
/**
* 这个方法是针对数组的遍历功能,将数组按照指定格式输出,输出格式如下:
* [元素1, 元素2, 元素3, 元素4,....元素n]
* @param arr 要传递的真实数组(要遍历的数组对象)
*/
public static void printArray(int[] arr){
System.out.print("[");
for(int x = 0; x <arr.length; x++){
//如果x角标取到最大索引值
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else{
System.out.print(arr[x]+", ");
}
}
}
/**
* 这个方法是获取数组中的最大值;
* @param arr 要传递数组对象,在这里面查询最大值
* @return 返回数组中的最大值
*/
public static int getMax(int[] arr){
int max = arr[0];
for(int x =1; x <arr.length; x++){
if(arr[x]>max){
max = arr[x];
}
}
return max;
}
/**
* 这个方法是获取数组中第一次出现索引值
* @param arr 要查询的数组
* @param key 要查找在数组中的指定的元素
* @return 返回的就是数组的元素第一次出现的索引值,否则,返回-1
*/
public static int getIndex(int[] arr,int key){
int index = -1;
for(int i = 0; i <arr.length; i++){
if(key == arr[i]){
index = i;
break;
}
}
return index;
}
/**
* 这个方法是对数组进行冒泡排序
* @param arr 要将数组进行排序
*/
public static void bubleSort(int[] arr){
for(int x = 0; x < arr.length -1; x++){
for(int y = 0; y < arr.length-1-x; y++){
if(arr[y] >arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
}
7.代码块
-
代码块 ----> 使用{}括起来的内容
-
分类:
-
局部代码块,就是在方法定义中使用{}
-
{},作用:就是限定局部变量的生命周期;
-
-
构造代码块:—在类的成员位置定义的{}
-
特点:在执行构造方法之前,如果类中有构造代码块,则优先执行构造代码块 * 作用:也可以给类的成员的数据进行初始化 -
只要执行构造方法,如果存在构代码块,它必须优先执行,然后才是构造方法...
-
-
静态代码块:
-
类就加载一次,静态代码块也就执行一次
-
格式 ----> 跟静态相关的都和类有关系,随着类的加载而加载
static{ //里面书写代码 }
-
-
优先级:
- 静态代码块 > 构造代码块> 构造方法,并且每次执行构造方法之前,优先执行所有的构造代码块
//测试类 public class CodeDemo { public static void main(String[] args) { //局部代码块 { int y = 20 ; System.out.println(y); } System.out.println("----------------------------------------------") ; Code code = new Code(); Code code1 = new Code("华为"); } } class Code{ { int x = 100; System.out.println(x); } //无参 public Code(){ System.out.println("code"); } { int y = 1000; System.out.println(y); } //静态代码块 static { int z = 10000; System.out.println(z); } //有参 public Code(String brand){ System.out.println("brand:" + brand); } } -
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
