1. static(静态)
1.1静态变量
static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量。
被static修饰的成员变量，叫做静态变量
特点：1. 被该类所有对象共享。
static修饰的，静态变量是随着类（类加载到方法区）的加载而加载（在堆空间开辟一块地址存储静态变量）的，优先于对象出现的。
静态变量：存储在静态存储区，静态区（在堆内存中）。
2.静态变量不属于对象，属于类。
3 随着类的加载而加载，优于对象存在。
调用方式：类名调用（推荐），对象名调用
1.2 静态方法
被static修饰的成员方法，叫做静态方法
特点：
多用在测试类和工具类中
javabean类中很少会用
工具类：帮助我们做一些事情，但是不描述任何事物的类。
类名见名知意
私有化构造方法。不可以创建对象
方法定义为静态。
调用方式：
类名调用（推荐）
对象名调用
类的分类
Javabean类：用来描述一些事物的类，如Student、Cat等。
测试类：用来检查其他的类是否书写正确，带有main方法的类，是程序的入口。
工具类：不是用来描述一类事物的，而是帮助我们做一些事情的类。
工具类举例
package staticDemo;
public class ArrayUtil {
//私有化构造方法
//目的：为了不让外界创建他的对象
private ArrayUtil(){}
//定义静态方法
public static String printArr(int[] arr){
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i=0;i<arr.length;i++){
if(i == arr.length-1){
sb.append(arr[i]);
}else{
sb.append(arr[i]+",");
}
}
sb.append("]");
return sb.toString();
}
//返回平均分
public static Double getAverage(double[] arr){
double sum = 0;
for(int i=0;i<arr.length;i++){
sum += arr[i];
}
return sum/arr.length;
}
}练习：
需求：定义一个集合，用于存储三个学生对象
学生类的属性为：name、age、gender
定义一个工具类，用于获取集合中最大学生的年龄
JavaBean类：
package staticDemo;
public class Student {
private String name;
private int age;
private String gender;
public Student() {
}
public Student(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}工具类：
package staticDemo;
import java.util.ArrayList;
public class StudentUtil {
private StudentUtil(){}
public static int getMaxAge(ArrayList<Student> stu){
int maxAge = stu.get(0).getAge();
for (int i = 1; i < stu.size(); i++) {
int age = stu.get(i).getAge();
if (age > maxAge) {
maxAge = age;
}
}
return maxAge;
}
}测试类：
package staticDemo;
import java.util.ArrayList;
public class TestDem01 {
public static void main(String[] args) {
/*需求：定义一个集合，用于存储三个学生对象
学生类的属性为：name、age、gender
定义一个工具类，用于获取集合中最大学生的年龄
*/
//1.定义一个学生集合
ArrayList<Student> list = new ArrayList<>();
//2.定义三个学生对象
Student s1 = new Student("name",12,"man");
Student s2 = new Student("name1",13,"man");
Student s3 = new Student("name2",14,"man");
//3.将创建对象加入到集合中
list.add(s1);
list.add(s2);
list.add(s3);
int maxAge = StudentUtil.getMaxAge(list);
System.out.println(maxAge);
}
}1.3 static的注意事项
静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量和静态方法，也可以访问非静态的成员变量和非静态的成员方法。
静态方法中是没有this关键字。
this表示当前调用者的地址值
这个this：是由虚拟机赋值的.
总结：
静态方法中，只能访问静态
非静态方法中可以访问所有
静态方法中没有this关键字
1.4 重新认识main方法。
2 继承
2.1 继承概述
回顾
封装：对象代表什么，就得封装对应的数据，并提供数据对应的行为。
继承
继承是面向对象三大特征之一，可以让类跟类之间产生子父的关系。
java中提供一个关键字extends，用这个关键字，我们就可以让一个类和另一个类建立起继承关系。
pubilc class Student extends Person{}
Student称为字类（派生类），Person称为父类(基类或超类)
使用继承的好处：
可以把多个子类中重复的代码抽取到父类中，提高代码的复用性。
子类可以在父类的基础上，增加其他的功能，使子类更强大。
继承需要学习的点：
自己设计：
什么时候使用继承？
当类与类之间，存在相同（共性）的内容，并满足子类是父类的一种，就可以考虑使用继承，来优化代码
使用别人的
2.2 继承的特点
Java只支持单继承，不支持多继承，但支持多层继承。
单继承：一个子类只能继承一个父类。
不支持多继承：子类不能同时继承多个父类
多层继承：子类A继承父类B，父类B可以继承父类C
注意：每一个类都直接或间接的继承于Object
继承的练习
理清思路：画图，从下往上画
书写代码：从上向下写
动物类
package oopExtends.demo1;
public class Animal {
public void eat(){
System.out.println("吃东西");
}
public void drink(){
System.out.println("喝水");
}
}猫类：
package oopExtends.demo1;
public class Cat extends Animal {
public void catchMouse(){
System.out.println("cat catch mouse");
}
}狗类：
package oopExtends.demo1;
public class Dog extends Animal{
public void lookHone(){
System.out.println("Dog looks hone");
}
}布偶猫：
package oopExtends.demo1;
public class Ragdoll extends Cat{
}狸花猫：
package oopExtends.demo1;
public class LiHua extends Cat{
}哈士奇：
package oopExtends.demo1;
public class Husky extends Dog{
public void breakHome(){
System.out.println("Husky is breaking home.");
}
}泰迪：
package oopExtends.demo1;
public class Teddy extends Dog {
public void touch(){
System.out.println("Teddy is touching my leg.");
}
}测试类：
package oopExtends.demo1;
public class Test {
public static void main(String[] args) {
//创建对象并调用方法
Ragdoll rd = new Ragdoll();
rd.eat();
rd.drink();
rd.catchMouse();
Husky h = new Husky();
h.eat();
h.drink();
h.lookHone();
h.breakHome();
}
}注意：private(权限修饰符)：此时子类就无法访问了。
2.3 子类能继承父类中的哪些内容（内存图/内存分析工具）
2.4 继承中成员变量和成员方法的访问特点
2.4.1 继承中：成员变量的访问特点
就近原则：谁离我近，我就用谁
继承中成员变量访问特点：就近原则
先在局部位置找，本类成员位置找，父类成员位置找，逐级往上。
如果成员变量重名怎么办？
System.out.println(name);在局部位置往上找
System.out.println(this.name);本类成员位置往上找
System.out.println(super.name);父类成员位置往上找
2.4.2 继承中：成员方法的访问特点
直接调用满足就近原则：谁离我近，我就用谁
super调用，直接访问父类
方法的重写：
当父类的方法不能满足子类现在的需求时，需要进行方法重写。
书写格式：
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
@Override重写注解
1.@Override是放在重写后的方法上，检验子类重写时语法是否正确。
2.加上注解后如果有红色波浪线，表示语法错误。
3建议重写方法都加@Override注解，代码安全，优雅！
方法重写注意事项和要求： 1.重写方法的名称、形参列表必须与父类中的一致。
2.子类重写父类方法时，访问权限子类必须大于等于父类。
3.子类重写父类方法时，返回值类型必须小于等于父类。
建议：重写的方法尽量和父类保持一致
5.私有方法不能被重写。（只有被添加到虚方法表中的方法才能被重写）
6.子类不能重写父类的静态方法，如果重写会报错
练习：
父类：
package oopExtends.demo2;
public class Dog {
public void eat(){
System.out.println("Dog eats food");
}
public void drink(){
System.out.println("Dog drinks water");
}
public void lookHome(){
System.out.println("Dog looks home");
}
}子类：
package oopExtends.demo2;
public class Husky extends Dog {
public void breakHome(){
System.out.println("Husky is breaking home.");
}
}
package oopExtends.demo2;
public class SharPei extends Dog {
//沙皮狗吃饭不一样，需要重写
@Override
public void eat() {
super.eat();//吃狗粮
System.out.println("SharPei is gnawing a bone");
}
}package oopExtends.demo2;
public class ChineseDog extends Dog{
@Override
public void eat() {
System.out.println("ChineseDog is eating the leftovers.");
}
}package oopExtends.demo2;
public class Testdemo {
public static void main(String[] args) {
Husky h = new Husky();
h.eat();
h.drink();
h.lookHome();
h.breakHome();
ChineseDog cd = new ChineseDog();
cd.eat();
cd.drink();
cd.lookHome();
SharPei sp = new SharPei();
sp.eat();
sp.drink();
sp.lookHome();
}
}
2.4.3 继承中：构造方法的访问特点
父类中的构造方法不会被子类继承。
子类中所有的构造房啊默认会先访问父类中的无参构造，再执行自己。
为什么？
1.子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
2.子类在初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。
怎么调用父类构造方法？
子类构造方法的第一行默认语句都是：super()，不写也存在，且必须在第一行。
如果想调用父类有参构造，必须手动写super进行调用。
继承中构造方法的访问特点？
子类不能继承父类的构造方法，但是可以通过super调用。
子类构造方法的第一行，有一个默认的super
默认先访问父类中的无参构造方法，再执行自己。
如果想要访问父类有参构造，必须手动书写。（super（q,w））
2.5 this,super的使用总结
this:理解为一个变量，表示当前方法调用者的地址值。
super:代表父类存储空间。
练习1：
父类：
package oopExtends.demo3;
public class Employee {
private String id;
private String name;
private double salary;
public Employee() {
}
public Employee(String id, String name, double salary) {
this.id = id;
this.name = name;
this.salary = salary;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public void work(){
System.out.println("Employee worked!");
}
public void eat(){
System.out.println("Employee eat mice!");
}
}子类：
package oopExtends.demo3;
public class Manger extends Employee{
private double bonus;
//空参构造
public Manger() {
}
//全参构造
//父类+子类
public Manger(String id, String name, double salary, double bonus) {
super(id, name, salary);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work(){
System.out.println("Manger is working.");
}
}package oopExtends.demo3;
public class Cook extends Employee {
public Cook() {
}
public Cook(String id, String name, double salary) {
super(id, name, salary);
}
@Override
public void work() {
System.out.println("Cook works");
}
}测试类：
package oopExtends.demo3;
public class Test {
public static void main(String[] args) {
Manger m = new Manger("001","qw",15000,8000);
System.out.println(m.getId() + "," + m.getName() +
"," + m.getSalary()+ "," + m.getBonus());
m.work();
m.eat();
Cook c = new Cook("002","er",8000);
c.setId("002");
c.setName("yu");
c.setSalary(8500);
System.out.println(c.getId() + "," +c.getName() + "," +c.getSalary());
c.work();
c.eat();
}
}标签：name,继承,子类,void,概述,static,父类,public,String From： https://blog.csdn.net/m0_57132040/article/details/143882096