7天学完Java基础之4/7
程序员文章站
2022-07-01 23:27:34
静态static 如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据 静态static 关键字修饰成员变量 静态static关键字修饰成员方法 一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类的 如 ......
静态static
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据
静态static 关键字修饰成员变量
public class student {
private string name;
private int age;
static string room;
public student() {
}
public student(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;
}
}
public static void main(string[] args){
student one = new student("郭靖",18);
//用对象名.变量名给变量赋值
one.room = "101";
student two = new student("黄蓉",16);
//姓名:郭靖 年龄18 教室105
system.out.println("姓名:" +one.getname()+" 年龄"+one.getage()+" 教室"+one.room);
//没有对two.room赋值但是也输出了教室101,可见被static修饰过的变量的数据是共享的
//姓名:黄蓉 年龄16 教室105
system.out.println("姓名:" +two.getname()+" 年龄"+two.getage()+" 教室"+two.room);
}
静态static关键字修饰成员方法
一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类的
如果没有static关键字，那么必须首先创建对象，然后通过对象才可以使用他
有static关键字可以通过类名.静态方法名调用方法
public class methoddemo {
public void method(){
system.out.println("这是一个成员方法");
}
public static void method1(){
system.out.println("这是一个静态方法");
}
}
public class methodtest {
public static void main(string[] args){
methoddemo one = new methoddemo();
//对象名调用方法
one.method();
//对象名调用方法
one.method1();
//类名调用静态方法
methoddemo.method1();
}
如果有了static，都推荐使用类名称来调用
注意事项
- 静态不能直接访问非静态
public class methoddemo {
int num ;
static int num1;
public void method(){
system.out.println("这是一个成员方法");
//成员方法访问成员变量和静态变量
system.out.println(num);
system.out.println(num1);
}
public static void method1(){
system.out.println("这是一个静态方法");
//静态方法访问静态变量
system.out.println(num1);
//静态方法不能够访问非静态变量
//system.out.println(num);编译报错
}
- 静态方法不能使用this，因为this代表当前对象，而静态方法属于类。
静态代码块
特点，当第一次用到本来的时候，静态代码块执行唯一一次
/*格式
public class 类名{
static{}
}*/
public class staticdemo {
static{
system.out.println("静态代码块执行了");
}
public staticdemo(){
system.out.println("构造方法执行了");
}
}
public class staticdemotest {
public static void main(string[] args) {
//静态代码块只会执行一次，并且优先于其他语句执行
staticdemo one =new staticdemo();
staticdemo two = new staticdemo();
}
}
//输出结果
静态代码块执行了
构造方法执行了
构造方法执行了
arrays工具类
public static string tostirng(数组),将参数数组变成字符串
public static void main(string[] args) {
int[] arrays= new int[]{1,2,3,4,5};
string[] arrays1 = new string[]{"骐骥一跃","不能十步","驽马十驾","功在不舍"};
//调用arraysd的tostring方法把数组变成字符串
string str = arrays.tostring(arrays);
string str1 = arrays.tostring(arrays1);
//打印字符串
system.out.println(str);
system.out.println(str1);
}
public static void sort(数组),按照默认升序，对数组元素排序
public static void main(string[] args) {
int[] arrays= new int[]{1,63,45,55,88};
string[] arrays1 = new string[]{"骐骥一跃","不能十步","驽马十驾","功在不舍"};
//对数组进行排序
arrays.sort(arrays);
arrays.sort(arrays1);
//排序完之后，把他变成字符串，打印输出
system.out.println(arrays.tostring(arrays));
system.out.println(arrays.tostring(arrays1));
//输出结果如下
//[1, 45, 55, 63, 88]
//[不能十步, 功在不舍, 驽马十驾, 骐骥一跃]
}
arrays字符串倒序练习
public static void main(string[] args) {
//先创建一个字符串
string str = "ersdf485dfw";
//要排序字符串，需要把字符串变成char数组，可以使用tochararray方法
char[] chars = str.tochararray();
//把字符串用sort方法排序好
arrays.sort(chars);
//然后就可以for循环遍历来倒序
//chars数组的最大索引为长度减一，索引为0也有元素，索引需要>=0
for(int i=chars.length-1;i>=0;i--){
system.out.println(chars[i]);
}
}
继承
继承的格式
public class zi extends fu{}
继承中成员变量的访问特点
在子父类的继承关系当中，如果有成员变量重名，则创建子类对象时，访问有两种方式
直接通过子类对象访问成员变量
等号左边是谁，就优先有谁，没有则向上找
public class fu {
//父类
int num = 100;
}
public class zi extends fu{
//子类
int num = 200;
}
public static void main(string[] args) {
zi zi = new zi();
//输出的时100还是200？
system.out.println(zi.num);//200
}
间接通过成员方法访问成员变量
方法属于谁，就优先用谁，没有则向上找
public class fu {
//父类
int num = 100;
public void methodfu(){
system.out.println(num);
}
}
public class zi extends fu{
int numzi = 10;
int num = 200;
public void methodzi(){
system.out.println(num);
}
public static void main(string[] args) {
zi zi = new zi();
//输出的时100还是200？
system.out.println(zi.num);//200
//这个方法是子类的，优先使用子类的成员变量
zi.methodzi();//200
//这个方法是父类的，优先使用父类的成员变量
zi.methodfu();//100
}
区分子类方法中重名的三种变量
public class fu {
int num = 10;
}
public class zi extends fu{
int num = 20;
public void method(){
int num = 30;
//输出局部变量
system.out.println(num);
//输出本类变量
system.out.println(this.num);
//输出父类变量
system.out.println(super.num);
}
}
/*
*局部变量:
* 本类的成员变量
* 父类的成员变量
* */
public class extendstest {
public static void main(string[] args) {
zi zi = new zi();
//调用zi类方法
zi.method();
}
}
继承中成员方法的访问特点
public class fu {
public void methodfu(){
system.out.println("父类方法");
}
public void method(){
system.out.println("父类重名方法执行");
}
}
public class zi extends fu{
public void methodzi(){
system.out.println("子类方法执行");
}
public void method(){
system.out.println("子类重名方法执行");
}
}
public class extendstest {
public static void main(string[] args) {
zi zi = new zi();
//调用zi类方法
zi.methodfu();
zi.methodzi();
//方法重名，优先使用子类方法
zi.method();
}
}
重写（override）
概念：在继承关系当中，方法的名称一样，参数列表也一样
重写（override），方法的名称一样，参数列表也一样
重载（overload），方法的名称一样，参数列表不一样
继承中构造方法的访问特点
public class fu {
public fu(){
system.out.println("我是无参数的父类构造方法");
}
public fu(int num){
system.out.println("我是有参数的父类重载构造");
}
}
public class zi extends fu{
public zi(){
//在继承关系中，编译器都会默认赠送一个super()父类构造方法;
//而且还是在子类构造方法的第一行，所以在new对象的时候会先执行
// 父类的构造方法
// super();
super(5);
//在继承关系中，子类会有一个默认的super();
system.out.println("子类构造方法");
}
}
/*
继承关系中，父子类构造方法的访问特点
1.子类构造方法当中有一个默认隐含的"super()"调用
2.子类构造可以通过super关键字来调用父类重载构造
super的父类构造调用，必须在构造方法的第一句
*/
public class constructordemo {
public static void main(string[] args) {
zi zi = new zi();
//父类构造方法
//子类构造方法
}
}
super关键字的三种用法
1.在子类的成员方法中，访问父类的成员变量。super.numfu
2.在子类的成员方法中，访问父类的成员方法。super.methodfu
3.在子类的构造方法中，访问父类的构造方法。
this关键字的三种用法
super关键字用来访问父类内容，而this关键字用来访问本类内容，用法也有三种
1.在本类中的成员方法中，访问本类的成员变量
public class zi extends fu {
int num = 55;
public void athis() {
int num = 66;
system.out.println(num);//66
system.out.println(this.num);//55
}
}
2.在本类的成员方法中，访问本类的另一个成员方法，
int num = 55;
public void athis() {
int num = 66;
system.out.println(num);//66
system.out.println(this.num);//55
}
public void bthis(){
system.out.println("bbb");
}
public void cthis(){
this.athis();
system.out.println("ccc");
}
public static void main(string[] args) {
new zi().cthis();//输出结果为66 55 ccc
}
3.在本类的构造方法中，访问本类的另一个构造方法
public zi(){
//重载构造方法两个
//调用下一个构造方法
this(123);
}
public zi(int n){
//调用下一个构造方法
this(1,2);
}
public zi(int a,int b){
}
//注意this()调用跟super()一样也必须是构造方法的第一个语句，super和this两张构造调用，不可以同时使用。
练习
public class fu {
int num = 5;
public fu(){
system.out.println("我是构造方法");
}
public void method(){
system.out.println("我是父类");
}
}
public class zi extends fu {
int num = 6;
public void method1(){
int num = 7;
system.out.println(num);
system.out.println(this.num);
system.out.println(super.num);
}
@override
public void method(){
super.method();
system.out.println("我是子类");
}
}
public class constructordemo {
public static void main(string[] args) {
zi zi = new zi();
zi.method1();
zi.method();
//我是构造方法
//7
//6
//5
//我是父类
}
}
java继承的三个特点
1.java语言是单继承的，一个类的直接父类只有由唯一一个
- java语言可以多级继承，也就是a类继承b类,b类继承c类
- 一个类的直接父类是唯一的，但是父类可以由很多个子类,
抽象类
public abstract class 类名{
public abstract void 方法名(){}
//抽象类中也可以定义普通成员方法
public void 方法名(){}
}
抽象方法和抽象类的使用
- 抽象类不能够直接new的抽象类对象
- 必须用一个子类继承抽象类才可以使用
- 子类必须重写抽象父类当中的所有抽象方法
- 创建子类对象进行使用
抽象方法和抽象类的注意事项
抽象类不能够创建对象
抽象类，可以有构造方法的，是供子类创建对象时，初始化成员使用的
抽象类中，不一定包含抽象方法，但是抽象方法一定包含在抽象类中
抽象类的子类，必须重写抽象父类的所有抽象方法
红包案例
public class auser {
private int money ;
private string name ;
public auser() {
}
public auser(int money, string name) {
this.money = money;
this.name = name;
}
public int getmoney() {
return money;
}
public void setmoney(int money) {
this.money = money;
}
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
public void show(){
system.out.println("我"+name+"现在的余额是"+money);
}
}
import java.lang.reflect.array;
import java.util.arraylist;
public class admin extends auser{
public admin() {
}
public admin(int abalance, string aname) {
super(abalance, aname);
}
public arraylist<integer> send(int totalmoney, int count){
arraylist<integer> redlist = new arraylist<>();
int i= totalmoney/count;
//判断群主有多少钱
int leftmony = super.getmoney();
if(totalmoney>leftmony){
system.out.println("余额不足");
return redlist;
}
//扣钱
super.setmoney(leftmony -totalmoney);
int avg = totalmoney/count;
int mod = totalmoney%count;
for(int d=0;d<count-1;d++){
redlist.add(avg);
}
int last= avg+mod;
redlist.add(last);
return redlist;
}
}
import java.util.arraylist;
import java.util.random;
public class menber extends auser{
public menber() {
}
public menber(int money, string name) {
super(money, name);
}
public void receive(arraylist<integer> list){
int index = new random().nextint(list.size());
int delta = list.remove(index);
int money = super.getmoney();
super.setmoney(money+delta);
}
}
import java.util.arraylist;
public class redpacket {
public static void main(string[] args) {
admin admin = new admin(100,"群主");
menber one = new menber(0,"aaa");
menber two = new menber(0,"aaa");
menber three = new menber(0,"aaa");
admin.show();
one.show();
two.show();
three.show();
arraylist<integer> redlist = admin.send(20,3);
one.receive(redlist);
two.receive(redlist);
three.receive(redlist);
admin.show();
one.show();
two.show();
three.show();
}
}