进阶篇
（一）、静态变量
假如说:在一个班级里面有n名学生，每一名学生的姓名。年龄、学号都不一样，我们可以通过创建Student类来对每一名学生进行赋值的操作。然而呢，老师的名字只有一个，那名字肯定也是相同的啊。如果我们在定义老师的名字的时候利用正常的成员变量。那么每次操作一个学生，我们都要对这个老师进行赋值的操作，那么程序会显得有一点笨重。这时候我们就可以使用STATIC静态变量对其操作运行。
1.成员变量是private：
Student类:
public class Student {
private String name;
private int age;
private int id;
main类:
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
Student stu1=new Student();
stu1.setAge(18);
stu1.setName("吉士先生");
stu1.setId(21032114);
stu1.study();
stu1.show();
Student stu2=new Student();
stu2.setAge(20);
stu2.setName("傻瓜");
stu2.setId(21032118);
stu2.study();
stu2.show();
}
}
类对象能访问公有权限的成员变量和公有的成员方法。哪个对象调用这个方法得话，那么就输出和设置这个对象的数据
2.成员变量是public:
Student类:
public class Student {
private String name;
private int age;
private int id;
public String teacher; //公有变量
main类:
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
Student stu1=new Student();
stu1.setAge(18);
stu1.setName("吉士先生");
stu1.setId(21032114);
stu1.teacher="大聪明"; //通过调用成员变量进行操作
stu1.study();
stu1.show();
Student stu2=new Student();
stu2.setAge(20);
stu2.setName("傻瓜");
stu2.setId(21032118);
stu2.study();
stu2.show();
}
}
因为我们只对学生对象1进行赋值操作，所以我们此时此刻的对象2的老师的那个位置是空的。
3成员变量是static
student类:
public class Student {
private String name;
private int age;
private int id;
static String teacher;
main方法:
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
Student stu1=new Student();
Student.teacher="大聪明"; // 通过类名.静态成员变量名对其进行赋值.类对象也可以
stu1.setAge(18);
stu1.setName("吉士先生");
stu1.setId(21032114);
stu1.study();
stu1.show();
Student stu2=new Student();
stu2.setAge(20);
stu2.setName("傻瓜");
stu2.setId(21032118);
stu2.study();
stu2.show();
}
}
因为静态变量是归类所有的，并不是某一个对象所有的
静态变量:优先于类对象的创建在堆里面。
（二）、类的三种格式:
工具类:
1.JavaBean 类:
2.测试类:
3.工具类:
工具类：实质上就是方法（构造函数用私有的）
代码展示:
工具类:
public class Util {
private Util(){
};
//整数数组转成字符串:
public static String ArrayChangeString(int []a){
StringBuilder sb=new StringBuilder();
sb.append("[");
for(int i=0;i<a.length;i++){
if(i==a.length-1){
sb.append(a[i]);
}else{
sb.append(a[i]).append(","+" ");
}
}
sb.append("]");
return sb.toString();
}
//求一个数组的平均数:.
public static double Average(int []a){
int sum=0;
for(int i=0;i<a.length;i++){
sum+=a[i];
}
return sum/a.length;
}
}
测试类:
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
int []a=new int[]{
1,2,3,4,5,8};
System.out.println(Util.ArrayChangeString(a));
int []b=new int[]{
1,2,3,5,8,7,6,9};
System.out.println(Util.Average(b));
}
}
工具类 测试类 JavaBean类。三则连用
题目描述:
有一个对象集合，对象的属性是name score id.请你在工具类中实现类对象中最大的值，然后返回它的类对象。并且后输出所有的值信息。
工具类:
public static Student FindMaxScore(ArrayList<Student> stu){
double max;
Student s=stu.get(0);
max=s.getScore();
for(int i=1;i<stu.size();i++){
Student s1=stu.get(i);
double num=s1.getScore();
if(num>max){
s=s1; //对象拷贝
}
}
return s;
}
JavaBean类:
public class Student {
private String name;
private double score;
private String ID;
public Student() {
}
public Student(String name, double score, String ID) {
this.name = name;
this.score = score;
this.ID = ID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
}
测试类:
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
ArrayList<Student> stu=new ArrayList<>();
Student s=new Student("吉士先生",94.3,"256dsd");
Student s1=new Student("小姐也",56.6,"22222d");
Student s2=new Student("大聪明",96.3,"11111d");
stu.add(s);
stu.add(s1);
stu.add(s2);
Student s3=Util.FindMaxScore(stu);
System.out.println("最大值的信息是:"+s3.getName()+" "+s3.getScore()+" "+s3.getID());
}
}
(三)、sattic的注意事项:(多用在测试类和工具类)
非静态方法只有通过实列化之后才能被调用(也就是new之后)
因为在同一个类中，可以不用套娃.
1.静态方法中没有this指针:
正常的非静态方法中，都会在()里面有一个被隐藏的this指针。这个this指针我们是不能在里面添加元素的，因为这个this是虚拟机虚拟的。this是指谁调用这个函数，那么this就是谁。因为静态方法是归类的全部所有的，所以this指针是没用的。
2.静态方法只能访问静态:
3.非静态方法可以调用所有
(四)、继承:
1.什么时候用到继承:
当类与类之间存在多个共同关系的时候，我们可以设置继承关系。把相同的关系放到基类中去，不同的再分别放到派生类中去。
2.JAVA继承的特点
1.单继承：一个子类只能继承一个父类。
2.不支持多继承: 不能同时继承多个父类。（不同于C++）
3.支持多层继承:
4.java时直接继承或间接继承Object类的。
3.继承权限:
构造方法 ：不管什么权限都是不能够继承的。
成员变量：不管什么权限都是能继承的， 只不过public权限的能够直接使用。private的只能借助公有权限的成员方法才能使用。继承和使用是两回事。
成员方法:当权限是非私有、非static、非final的时候就能够被结成和使用.
基类会生成虚方法表，然后当作家谱往后传
（五）、派生类对成员的访问
1.成员变量的访问规则
遵循：就近原则.
基类:
public class Person {
String name; //没有访问权限 默认为public
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
派生类:
public class Student extends Person{
private String name="xiaohei";
public void show(){
String name="小王";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
测试类:
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
Student s=new Student();
s.setName("李明");
s.show();
}
}
2.成员方法的访问规则:
遵循就近原则:
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
public static void main(String[] avgs) {
Student s=new Student();
s.A();
}
}
class Teacher{
public void eat(){
System.out.println("吃教师的饭");
}
public void drink(){
System.out.println("喝教师的水");
}
}
class Student extends Teacher{
@Override
public void eat() {
System.out.println("吃学生的......");
}
@Override
public void drink() {
System.out.println("喝学生的......");
}
public void A(){
eat();
drink();
this.eat();
this.drink();
super.eat();
super.drink();
}
}
如果在派生类中，没有对基类的方法进行覆盖。那么输出的结构将都是吃老师的反 喝老师的水。
3.方法的重写
当父类的方法不能满足子类的要求的时候，那么我们需要重写方法。对子类的方法进行重写新的方法。（B继承C,A继承B。如果B发生覆盖。那么A继承的B也是更改的）
重写的注意事项:
1.子类方法名和形参列表要和父类完全相同。
2.子类重新方法的时候访问权限一定要大于等于父类的访问权限。
3.子类重新父类的方法时，返回值类型必须小于等于父类。
4.只有被添加到虚方法表中的方法才能被填写。