java进阶笔记Day(一)

继承
继承描述的是类与类之间的关系，当子类继承父类的时候，子类既可以使用子类自己的内容，也可使用父类的内容。

继承的好处
1.提高了代码的复用性
2.提高了代码的可维护性
3.是多态的前提(了解)
继承的弊端
继承增强了代码的耦合性(类于类之间的关系更加紧密)

继承的特点
1.单继承：一个子类只能有一个父类（一个儿子只能有一个爸爸）
2.多层继承：一个父类也可以有父类(爸爸也可以有爸爸)
继承的格式

public class 父类{
//成员方法变量
//成员方法
//构造方法
}
​
//继承的格式
public class 子类 extends 父类{
//成员方法变量
//成员方法
//构造方法
}
定义一个Person类

/*
属性：姓名、年龄
行为：吃饭、睡觉
*/
public class Person{
//属性：姓名、年龄
private String name;
private int age;

//alt+insert构造方法和get以及set方法自动生成

//行为：吃饭、睡觉
public void eat(){
System.out.pritnln(“人在吃饭”);
}
public void sleep(){
System.out.pritnln(“人在睡觉”);
}
}
定义学生类

/*
学生特有的属性和行为：
属性：学号
行为：学习
*/
public class Student extends Person{
//属性：学号
private String id;
//alt+insert自动生成构造方法以及get和set方法
//行为：学习
public void study(){
System.out.println(“学生在学习”);
}
}
成员变量的访问特点
子父类成员变量的访问遵循就近原则
子类局部有就用子类局部的
子类局部没有，就用子类成员的
子类成员也没有，就用父类成员的（也可以是父类的父类）

public Fu{
int num=10;
}
public class Zi extends Fu{
int num=20;
public void show(){
int num=30;
System.out.println(num); //30 当前方法的局部变量
System.out.println(this.num); //20 本类的成员变量
System.out.println(super.num); //10 父类的成员变量
}
}
public class Demo1{
public static void main(String[] args){
Zi z=new Zi();
z.show();
}
}
this和super

this：本类对象的引用
this.成员变量 调用本类的成员变量
this.成员方法 调用本类的成员方法
this() 调用本类的空参数构造方法
this(参数) 调用本类的有参数构造方法

super：父类对象的引用
super.成员变量 调用父类的成员变量
super.成员方法 调用父类的成员方法
super() 调用父类的空参数构造方法
super(参数) 调用父类的有参数构造方法
​
注意：this(…) 或者 super(…) 只能使用在构造方法的一条语句。
this和super构造方法的访问流程图解

this和super成员方法的访问流程

构造方法的访问特点

1.子类的所有构造方法都会默认的去访问父类的空参数构造方法。
在构造方法的第一条语句其实隐含的有一句super()，调用父类的空参数构造方法

2.如果父类没有空参数构造方法，可以采用下面的解决方案
1) 可以通过super(参数)去访问父类有参数的构造方法
2) 在父类中加上一个空参数构造方法【推荐使用】

【小结：无论如何，子类的构造方法必须要访问父类的构造方法。】
成员方法的访问
当子类和父类有一模一样的方法时，我们就认为子类复写(重写、覆盖)了父类的方法，这时去调用这个方法执行的就是子类复写的方法。
方法复写的意义：方法复写既保证父类方法不变，子类也有自己的实现。
方法复写的注意事项

1.可以使用@Override，检测是否符合方法复写的规则
2.子类方法的权限必须大于或者等于父类
public > protected > 默认的(不写) > private
3.私有的方法不能复写
4.子类方法的返回值类型必须小于或者等于父类
【注意：建议复写方法时，子类和父类方法写的一样就可以了】
老师和学生案例
类

package com.itheima05;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
}
Student类

public class Student extends Person {
public Student() {
super();
}
public Student(String name, int age) {
super(name, age);
}
//学生
public void study(){
System.out.println(“学习在学习”);
}
}
Teacher类

public class Teacher extends Person {
public Teacher() {
}
public Teacher(String name, int age) {
super(name, age);
}
//教课
public void teach(){
System.out.println(“老师在教课”);
}
}
测试类

public class Demo5 {
public static void main(String[] args) {
Student stu=new Student();
stu.setName(“小明”);
stu.setAge(20);
System.out.println(stu.getName()+","+stu.getAge());
Student stu2=new Student(“小强”,18);
System.out.println(stu2.getName()+","+stu2.getAge());

    System.out.println("---------");
  
    Teahcer t1=new Teahcer();
    t1.setName("老王");
    t1.setAge(18);
    System.out.println(t1.getName()+","+t1.getAge());
    Teahcer t2=new Teahcer("大王",20);
    System.out.println(t2.getName()+","+t2.getAge());
}

}
其他的关键字
package【了解】

定义包格式：告诉JVM我们所写的类在哪个包下(文件夹)
package 包名; //包名命名规则：每一个单词都是小写的，多级包使用"."进行分割
包的作用：
对类文件(.java文件)进行分类管理
带包的编译：
javac -d . 类名.java
带包的运行：
java 包名.类名;
import关键字

import表示导包的含义，当在一个类中用到其他包中的类就需要导包。
//格式如下：
import 包名.类名;
例如：import java.util.ArrayList; import java.util.Random;
import 包名.; //导入指定包中的所有类 【了解】
例如：import java.util.;
final关键字

final是最终的意思，可以用来修饰类、方法、变量
​

• final修饰类：不能被继承

• final修饰方法：不能被复写

• final修饰变量：不能被修改(只能被赋值一次)
  final修饰引用类型的变量，表示地址值不能被改变

• final修饰成员变量：是没有默认的，必须在使用之前手动的进行赋值
  1)在定义变量时，直接赋值
  2)通过构造方法赋值
  static关键字

static关键字的特点
1.static修饰的变量可以被该类的所有对象共享
2.被static修饰的变量或者方法，【推荐使用类名直接调用】
Student.num;
Student.show();
3.静态的方法只能去调用静态方法或者静态变量
4.非静态的方法既能调用静态方法，也能调用静态变量
5.静态的方法中不能写this关键字
应为静态是属于类的，不属于任何一个对象；而this就表示一个对象的引用
静态是优先于对象存在的，所以当静态方法存的时候还不存在对象。
静态应用
通常为了方便使用，我们可以把一个类中所有的方法写成静态的，那么调用方法时就直接使用类名调用。
把这样的类叫做【工具类】

//专门用于操作数组的工具类
public class ArrayUtils {
//打印数组中的元素
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
System.out.println();
}
//求数组中元素的最大值
public static int getArrayMax(int[] array){
//假设0索引的元素为最大值
int max=array[0];
//遍历其他元素和max进行比较，把较大的值重新赋值给max
for (int i = 1; i < array.length; i++) {
if(array[i]>max){
max=array[i];
}
}
return max;
}
//求数组中元素的最小值
public static int getArrayMin(int[] array){
//假设0索引的元素为最小值
int min=array[0];
//遍历其他元素和max进行比较，把较小的值重新赋值给min
for (int i = 1; i < array.length; i++) {
if(array[i]<min){
min=array[i];
}
}
return min;
}
//求数组中元素的和
public int getArraySum(int[] array){
int sum=0;
for (int i = 0; i < array.length; i++) {
sum+=array[i];
}
return sum;
}
//求数组中元素的和
public int getArrayAvg(int[] array){
return getArraySum(array)/array.length;
}
//对数组元素进行逆序
public static void reverse(int[] array){
for (int start = 0,end=array.length-1; start < end; start++,end–) {
//把start和end位置的元素互换
int temp=array[start];
array[start]=array[end];
array[end]=temp;
}
}
}