Day08、09、10

二维数组

二维数组是由多个一维数组构成，声明：数据类型 [ ] [ ] 数组名;

数组的一些注意事项见Day07

静态初始化

静态初始化：数据由程序员指定，长度由系统根据数据个数开辟空间

public class S {public static void main(String[] args) {//静态初始化1String [][] a = new String[][]{{"小明","小红"},{"小亮","小马","小飞"}};//静态初始化2String [][] b ;b = new String[][]{{"小明","小红"},{"小亮","小马","小飞"}};//静态初始化3String [][] c ={{"小明","小红"},{"小亮","小马","小飞"}};//设置指定下标上的元素a[0][0] = "鸣人";//获取指定下标上的元素String name = a[0][0];System.out.println("获取指定下标上的元素:"+name);//获取长度System.out.println(a.length);//获取二维数组a中一维数组的个数System.out.println(a[0].length);//获取二维数组a中第一个一维数组中的元素个数System.out.println(a[1].length);//获取二维数组a中第二个一维数组中的元素个数System.out.println("--------------------");//for - 遍历for (int i = 0; i < a.length; i++) {for (int j = 0; j < a[i].length; j++) {System.out.println(a[i][j]);} }System.out.println("--------------------");//foreach - 遍历for (String[] ss : a) {for (String i : ss) {System.out.println(i);}}}
}

动态初始化

动态初始化：长度由程序员指定，数据由系统根据数组类型赋默认值（整数类型：0，浮点类型：0.0，字符类型：’ ’ （一个空格），布尔类型：false，引用类型：null）

public class S {public static void main(String[] args) {//动态初始化1String [][] a = new String[2][3];//两个一维数组，每个数组开辟三个连续的空间，系统会给默认值null//动态初始化2String [][] b ;b = new String[2][3];//设置指定下标上的元素a[0][0] = "小明";a[0][1] = "小红";a[0][2] = "小灵";a[1][0] = "小亮";a[1][1] = "小马";a[1][2] = "小飞";//for - 遍历for (int i = 0; i < a.length; i++) {for (int j = 0; j < a[i].length; j++) {System.out.println(a[i][j]);}    }System.out.println("--------------------");//foreach - 遍历for (String[] ss : a) {for (String i : ss) {System.out.println(i);}}}
}

面向对象

面向对象是门编程思想，是很抽象的一个概念，初学还是要慢慢消化理解。

类与对象概念

现实生活中：（对象——>类）

先有实体（对象），发现众多实体拥有共同的特征（属性）和功能（方法），就归为一类。

java世界中：（类——>对象）

程序员像造物主，先编写好类，该类的对象就会拥有相同的属性和方法。

类：类似于模板，刻画出对象应该拥有的属性和方法

对象：在代码中，实际操作的是对象，而不是类，这也是说为什么是面向对象而不是面向类

创建类

类里只有属性和方法，当使用面向对象设计思想，一定是先创建类，在创建对象

//人类
public class Person {//属性-全局变量：类里面、方法外的变量//  Person(){// //  }无参数构造//成员变量String name;char sex;int age;//成员方法public void eat(){System.out.println("吃饭");}public void sleep(){System.out.println("睡觉");}
}

创建对象及使用对象中的属性和方法

//测试类
public class Test{public static void main(String[] args){//使用对象//创建对象Person p = new Person();//Person()方法在Person类中若没有写则系统自动实现无参数构造,所以这里可以直接调用此方法//设置属性String name = "小明";char sex = '男';int age = 18;//获取属性System.out.println(p.name);System.out.println(p.sex);System.out.println(p.age);//调用方法p.eat();p.sleep;//Person类和Test类要在同一个包内}
}

小结：

属性-全局变量：类里面、方法外的变量

成员方法：没有用static修饰的方法

变量的分类：

属性-全局变量：成员变量（类里、方法外的变量，系统会赋默认值；其必须用对象调用）、静态变量

局部变量（方法中的变量，系统不会赋默认值）

测试类：测试写好代码的类，其重要的特征就是有main方法

局部变量与成员变量的区别：

局部变量是方法中的变量，系统不会赋默认值，成员变量是类里、方法外的变量，系统会赋默认值（成员变量必须用对象调用）

构造方法

含义：与类名相同且没有返回项的方法

注意：

没有参数的构造方法叫做无参构造

有参数的构造方法叫做有参构造

当一个类中没有有参构造时，无参构造系统会默认实现

当一个类中有有参构造时，无参构造系统不会默认实现（有需要的话只能程序员去写无参构造）

构造方法是可以重载的

作用：

和new关键字一起表示创建对象

使用有参构造，在创建对象时把属性依次给对象赋值

构造方法与成员方法的区别：

构造方法是创建对象时使用，成员方法是创建对象后利用对象调用

public class Person {String name;char sex;int age;public Person() {//无参构造}public Person(String name,char sex,int age) {//有参构造this.name = name;this.sex = sex;this.age = age;}
}

public class Test {public static void main(String[] args) {/* 当属性很多时，我们需要依次为其赋值，很繁琐* 利用有参构造，在创建对象时，就直接给对象赋值*/Person p = new Person("小明", '男', 18);}
}

（在同一个包下）

封装

好处：数据安全

步骤：

私有化属性

添加get/set方法

public class Student {private String name;private char sex;private int age;public String getName(){return name;}public void setName(String name){int length = name.length();if(length < 2 || length > 8){this.name = "默认名字";}else{this.name = name;}}public char getSex() {return sex;}public void setSex(char sex) {if(sex != '男' && sex != '女'){this.sex = '男';}else{this.sex = sex;}}public int getAge() {return age;}public void setAge(int age) {if(age < 0 || age > 150){System.out.println("年龄为错误数据");}else{this.age = age;}}
}

public class Test {public static void main(String[] args) {/*** 封装*/Student stu = new Student();stu.setName("小明");stu.setSex('男');stu.setAge(18);System.out.println(stu.getName());System.out.println(stu.getSex());System.out.println(stu.getAge());}
}

（在同一个包下）

private关键字

含义：私有化

作用：

修饰属性：私有化属性，该属性不能在类的外面直接使用（可间接使用）

修饰方法：私有化方法，该方法不能再类的外面直接使用（但是可以间接使用）

public class A {//私有化属性:在该类以外是不能直接使用（但是可以间接使用）private String str;//间接使用私有化的属性public void setStr(String str){this.str = str;}public String getStr(){return str;}//私有化方法，该方法不能在类的外界直接使用（但是可以间接使用）private void method01(){System.out.println("私有化方法");}//间接使用私有化的方法public void method02(){this.method01();}
}

public class Test{public static void main(String[] args) {/*** private关键字的使用*/A a = new A();a.setStr("xxx");System.out.println(a.getStr());a.method02();}
}

this关键字

含义：本对象（方法中的this代表调用该方法的对象）

作用：

this.属性：调用本对象的属性

this.方法：通过本对象调用方法

this()：调用构造方法（注意：是在A构造方法中的第一句调用B构造方法）

public class Student {private String name;private char sex;private int age;public Student() {//无参数构造//调用构造方法this("默认名字", '男', 18);}public Student(String name, char sex, int age) {//有参数构造，这和上面那个其实是方法的重载this.name = name;this.sex = sex;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void sleep(){System.out.println(this.name + "睡觉");}public void eat(){System.out.println(this.name + "吃饭");this.sleep();//通过this调用方法}
}

public class Test {public static void main(String[] args) {/*** this关键字*/Student stu1 = new Student();stu1.setName("小明");Student stu2 = new Student();stu2.setName("小亮");stu2.eat();Student stu3 = new Student();System.out.println(stu3.getName());System.out.println(stu3.getSex());System.out.println(stu3.getAge());}
}

（在同一个包下）

static关键字

含义：静态的

作用：

修饰属性：静态属性，是该类所有对象共享的变量；

生命周期：

创建：类加载到方法区时，系统会扫描整个类，并把类中的静态属性加载到静态区中。

销毁：项目结束时

修饰方法：静态方法，直接用类名调用即可

应用场景：工具类

静态代码块

应用场景：初始化数据

静态属性与成员属性的区别：

成员属性每个对象独享一份，静态属性所有对象共享一份

成员属性必须用对象调用，静态属性直接用类名调用

成员属性随着对象的创建而诞生、随着对象消亡而消亡

静态属性类加载时加载到静态区中，项目结束时消亡

静态代码块、代码块、构造方法之间的区别

共同点：都是初始化数据

静态代码块：初始化静态属性

代码块：初始化成员属性

构造方法：初始化成员属性

调用时机：

静态代码块：类加载到方法区时调用

代码块：创建对象，在调用构造方法之前调用

构造方法：创建对象，在调用代码块之后调用

（先后顺序：静态代码块——代码块——构造方法）

public class A {String str1;static String str2;
}

public class Test{public static void main(String[] args) {/*** static修饰属性：*/A a1 = new A();A a2 = new A();a1.str1 = "aaa";//成员属性由对象调用a2.str1 = "bbb";System.out.println(a1.str1);//aaaSystem.out.println(a2.str1);//bbb//静态变量属于类变量，直接用类名调用A.str2 = "xxx";System.out.println(A.str2);}
}

（在同一个包下）

public class A {//代码块可以调用成员属性，静态代码块不可以调用成员属性int i1;static int i2;//类加载到方法区时调用静态代码块static{//System.out.println("静态代码块" + i1);这里不可以调用i1System.out.println("静态代码块" + i2);}//创建对象时，在调用构造方法之间调用代码块{System.out.println("代码块" + i1);System.out.println("代码块" + i2);}public A() {System.out.println("构造方法");}}

public class Test{public static void main(String[] args) {/*** 静态代码块*/A a1 = new A();A a2 = new A();}
}

（在同一个包下）

super关键字

含义：父类

作用：

super.属性：调用父类的非私有化的属性

super.方法：调用父类的的非私有化的方法

super()：调用父类的非私有化的构造方法

public class Test {public static void main(String[] args) {/*** super关键字 -- 基本使用*/Son son = new Son();son.method();}
}
class Father{String str = "父类属性";public Father() {}public Father(String str) {this.str = str;}public void fatherMethod(){System.out.println("父类方法");}
}
class Son extends Father{public Son() {super("xxx");//调用父类的构造方法}public void method(){System.out.println(super.str);//在子类中调用父类属性super.fatherMethod();//在子类中调用父类方法}
}

分包

分包基本概念：防止类的重名

分包的项目概念：

一个项目可能会有几百个类，如果放在同一个包中，不方便管理。

在项目中一般会按照类的功能分包，例：

数据持久层的包：com.dr.dao

实体类的包：com.dr.vo/entity/bean

工具类的包：com.dr.util/tool

继承

概念：子类继承父类所有的属性和方法

优点：减少代码的冗余

应用场景：编写多个类时，发现多个类有共同的属性和方法，就把共同的属性和方法抽取到父类里

经典面试题：

子类能不能继承父类的私有化属性和方法？

能继承

创建子类对象，调用父类构造方法的目的？

在子类对象中开辟空间存放父类属性

创建子类对象，会创建父类对象吗？

不会

创建子类对象，先调用父类方法还是先调用子类构造方法？

先调用子类构造方法

创建子类对象，先完成父类方法还是先完成子类方法？

先完成父类构造方法

public class Test01 {public static void main(String[] args) {Son son = new Son();System.out.println(son.getAttr());//间接调用son.method02();//间接调用}
}class Father{private String attr = "父类私有化属性";public String getAttr() {return attr;}public void setAttr(String attr) {this.attr = attr;}private void method01() {System.out.println("父类私有化方法");}public void method02(){method01();}
}
class Son extends Father{}

public class Test02 {public static void main(String[] args) {Son son = new Son();   }
}class Father{public Father() {System.out.println("父类的无参构造");}
}class Son extends Father{public Son() {//这里在是调用父类构造方法，省略了super();System.out.println("子类的无参构造");}
}

方法的重写

应用场景：在父类方法不能改动且父类方法不满足子类需求时（也就是子类并不想原封不动地继承父类的方法，而是想作一定的修改）使用重写

注意：

重写的地方在子类里

返回值、方法名、参数个数及类型必须和待重写的父类方法一致

访问修饰符不能比待重写的父类方法更严格

重写到底怎么写——将待重写的父类方法复制到子类里，重写此方法里面的代码即可

访问修饰符

protected特点：提供给子类

默认：即不用public、private、protected访问修饰符的情况下

访问修饰符	本类	同一个包下	不同包的子类	其他包
private	ok
默认	ok	ok
protected	ok	ok	ok
public	ok	ok	ok	ok

JavaEE学习记录Day08、09、10相关推荐

小余学调度：学习记录（2021.10月）
小余学调度系列文章,记录小余同学入职电力调度员一路的学习记录,由于工作性质,在这个系列,只写能公开的知识点,不涉及机密. 提示:专栏解锁后,可以查看该专栏所有文章文章目录一.当线路处于并列运行时, ...
Java每天学习一点点 09.10.13
时间不等人呀,为什么不做一个自己每天的时间分段呢? 所以,先从每天学习一点Java开始吧.重在坚持,加油! 1. 在刚刚装好jdk,我们需要设置环境变量 path,我认为还是从我的电脑属性设置开始好 ...
C语言学习记录_2019.02.10
sizeof:给出某个类型或某个变量在内存中占据的字节数:(1个字节8位,即8比特) 格式符 (1)%ld表示数据按十进制有符号长型整数输入或输出. (2)%d表示数据按十进制有符号整型数输入或输出. ...
Java常用类(谷粒商城学习记录)
Java常用类谷粒商城学习记录谷粒商城学习记录谷粒商城学习记录干嘛老是提示我与别人的文章相似呢?真的是我自己整理的啊啊啊老是提示与这个文章相似 https://blog.csdn.net/c ...
王爽 16 位汇编语言学习记录
以下为汇编学习记录,内容全部出自王爽的16位<汇编语言>,如有错误,可直接去查看原书. 汇编语言机器语言是机器指令集的集合,机器指令是一列二进制数字,计算机将其翻译成高低电平,从而使 ...
python大神的成长之路_Python大神成长之路：第三次学习记录集合函数装饰 re...
学习记录day03 字符串可以直接切片,But字符串不可修改字符串修改:生成了一个新的字符串 LIst修改,在原基础上修改(原内存上) 集合是一个无序的,不重复的数据组合,它的主要作用如下: 去重, ...
磁盘配额（Quota）磁盘阵列（RAID）逻辑卷轴管理器（LVM）学习记录
磁盘配额(Quota)磁盘阵列(RAID)逻辑卷轴管理器(LVM)学习记录磁盘配额(quota) 启用Quota Quota指令 Quota实例软件磁盘阵列建立方法观察已建立装置出错救援方法 ...
linux个人学习记录
linux学习记录资料: Linux 黑马程序员_bilibili AcWing Linux基础课可能是东半球最全面易懂的 Tmux 使用教程! Shell 教程 | 菜鸟教程 (runoob.c ...
Python学习记录day6-反射、常用模块
Python学习记录day6-反射.常用模块 @(学习)[python] Python学习记录day6-反射常用模块反射常用模块 1 sys System-specific parameters ...

JavaEE学习记录Day08、09、10

Day08、09、10

二维数组

静态初始化

动态初始化

面向对象

类与对象概念

创建类

创建对象及使用对象中的属性和方法

构造方法

封装

private关键字

this关键字

static关键字

super关键字

分包

继承

方法的重写

访问修饰符

JavaEE学习记录Day08、09、10相关推荐

最新文章

热门文章