Java基础

最新推荐文章于 2024-07-31 19:38:21 发布

苏薄

最新推荐文章于 2024-07-31 19:38:21 发布

阅读量102

点赞数

分类专栏： c c++ java 文章标签： java

本文链接：https://blog.csdn.net/weixin_44764294/article/details/121403466

版权

c c++ java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java基础

文章目录

Java基础
标识符
- 转义字符
数据类型
分支结构
- if (表达式)
- switch(表达式 ){
循环
- break
- contine
数组
面向对象上
面向对象中
面向对象下
异常处理

标识符

Java 中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。在 Java 语言中，标识符的构成规则如下。

标识符由数字（0_{9）和字母（A}Z 和 a~z）、美元符号（$）、**下划线（_）**以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。
标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
识符命名时，切记不能以数字开头，也不能使用任何 Java 关键字作为标识符，

提示：Java 区分大小写

合法标识符：date、 $KaTeX parse error: Expected group after '_' at position 13: 2011、_date、D_̲$ date 等。
不合法的标识符：123.com、2com、for、if 等。

转义字符

\t一个制表位,对齐

\n 换行

\r 回车 System.out.println(“韩顺平教育\r北京”) //北京将把韩顺替换

数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iBCYhYDW-1637223028127)(C:\Users\mr.sun\Desktop\屏幕截图 2021-10-08 203901.png)]

3d 6F

字符型

.char = 'i’单引号是字符

char=" i"双引号会报错双引号表示字符

char c1 = 97 c1会输出a有

char c1 =‘b’+1 输出c1为c

char类型是可以进行运算的相当于一个整数,因为它都对应Unicoma码

布尔类型

boolean ispass = true java中只能用true或false不能用0或1代替

自动转换

精度小转精度大,不可逆转

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QeR9dKon-1637223028130)(C:\Users\mr.sun\Desktop\屏幕截图 2021-10-08 203901.png)]

位运算

"15 >> 2"就是15/2/2=3

'15<<3"就是15乘2乘2乘22

当a是小数时 a%b == a - (int)a/b *b

随机数

方式一

int num = (int) (Math.random() * 3)

Random rand =new Random(25);
int i;
i=rand.nextInt(100);

分支结构

if (表达式)

{ }

else

{ }

switch(表达式 ){

//表达式中的类型必须是(byte,short,int char,enum[枚举],String)没有double

case 常量 : //表达式内容与常量的类型需要一致

break;

case 常量 : //如果执行过一条条件了没有写break,就会穿透自动执行下面case 的语句

break;

…

default: //如果case没有匹配条件则执行default

//default可以不写

}

循环

for(){

}

while(){

}

do{

}while()

break

结束当前循环最近的那层循环直接结束 (后面不能加执行语句)

结束指定标识label的循环结构

contine

结束单次循环此次循环跳过进行这个循环的下一次 (后面不能加执行语句)

class  hellowworld{
     public static void main(String[] args) {
            for(int i;i<=10;i++)
            {
                if(i%4==0  ){
                  //break;//1,2,3会被输出
                  continue;//1,2,3,5,6,7,9,10会被输出
                }
                System.out.println(i);
            }
     }
}

数组

一维数组

int arr[]= new int[5]
int a[] ; a=new int[10]
int a[]={2,5,6,46,88}

错误形式:
1. int arr[];
  arr[]=new int[10];
2. int arr[];
  arr={1,2,3};

练习:遍历二维数组

二维数组

静态初始化

int[] [] arr1=new int[] []{{1,2,3},{4,5},{6,7,8}};
int[] [] arr1 ;

arr1=new int[] []{{1,2,3},{4,5},{6,7,8}};// 这个new int[] []不能省略,其他的都可以省略
int[] arr1[]=new int[] []{{1,2,3},{4,5},{6,7,8}};
int arr1[] [] =new int[] []{{1,2,3},{4,5},{6,7,8}};
int[] [] arr1={{1,2,3},{4,5},{6,7,8}};
int arr1[] []={{1,2,3},{4,5},{6,7,8}};

动态初始化

方式一

String[] [] arr2=new String[3] [2];

方式二

String[] [] arr3=new String[3] [];

错误的情况:

String[] [] arr2=new String[] [];
String[][] arr4=new String[][4];
String[4][5] arr5=new String[][];
int[][] arr6=new int[3][3]{{1,2,3},{4,5,7},{6,7,8}}

调用数组里元素

arr2[0] [1]第一个里的第二个

数组中的常见异常

角标越界索引超出左右边界角标从零开始
空指针

错误案例
int[] arr=new int[5];

arr=null;

System.out.print(arr[0])
int [] [] arr2=new int[4] [];

System.out.print(arr2[0] [0]) //没有给二维数组的列赋值,列为空值时不能调用;

数组工具类

面向对象上

属性和行为

封装继承多态

成员属性(成员变量)

class person{
	//成员属性(成员变量)自带默认值
	属性 可以加权限 public \ private\ protected
    String name;  
    private int id;
    int age;
    //成员方法(成员函数)
    1.方法可以调用当前类的属性
    public void eatting(){
        System.out.print( name +"人可以吃饭");
    }
     public void sleep(){
        System.out.print( name +"人可以睡觉");
    }

}

成员方法

成员方法的实例化,调用

形参,实参

package com.test;

public class method {`

    public static void main(String[] args) {
        ADD c1= new ADD();//类的实例化 
        c1.add(5,6);//调用成员函数
        System.out.println("xxx");
    }
}
class ADD{
    public void add(int a,int b){//形参可以有一个或多个,根据题意设置 
        int temp;//局部变量
        temp = a;
        a = b;
        b = temp;
        System.out.println(a);
    }

}

对象内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MfErZX33-1637223028132)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211104090614545.png)]

成员变量和局部变量

成员变量(属性): 直接定义在类的{ }内.

局部变量: 声明在方法内, 方法形参,代码块内,构造形参,构造器

内存结构: 栈(局部变量), 堆(new出来的结构:对象,数组)

return

适用范围:在方法中使用

两种用法:

1.结束方法

2.返回返回值

注意事项:return后不可以声明执行语句

对象数组

内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qha3JqfG-1637223028134)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211103093313929.png)]

匿名对象

不命名实现对象实例化

new person( )//创建了一个没有名字的对象

public class arrfuzhi {
public static void main(String[] args){
				//匿名做法:    匿名对象每次new都会在对空间创建新的对象
			
               new person().age=18;
               new person().eatting();
               //正常实例化:
               person p1=new person()
               p1.age  = 18;
               p1.person()
               phone shouji = new phone();
               shouji.show(new person())//用匿名做实参
        }
}
class person{
    protected String name;
    int id;
    int age;
    public void eatting(){
        System.out.print("人可以吃饭");
    }
class phone{
	public viod show(person p)
	{
		p.name;
		p.id;
	}
}

}

方法重载(overload)

重载 : 在同一个类中允许同名方法 只要参数类型或参数个数不同即可

错误形式:1. 方法void和int 2. 参数名字都不能构成重载

public static void main(String[] args){
              arr a1=new arr();
              a1.getsum(7,8);  //正常输出15   如果第一个getsum被注释就会输出15.0  属于类型自动提升
        }

}
class arr{

    public void getsum(int a ,int b)
    {
        System.out.print(a+b);
    }
    public void getsum(double a,double b)
    {
        System.out.print(a+b);
    }
    public void getsum(int a,String b)
    {
        System.out.print(a+b);
    }

}

可变个数形参的方法

用法: 类型… 形参名

注意事项:

方法的形参中只能有一个可变个数形参且只能有一个

public void getsum(String ... strs)
{
    System.out.print(i);
}

方法参数的值传递机制

基本数据类型,此时赋值的变量所保存的数据值

引用数据类型,此时赋值的是变量所保存的数据地址值

引用数据类型的值传递完成数据交换
public static void main(String[] args){
    int[] arr=new int[6];
    arr=new int[]{1,8,5,7,6,8};
    arr a1=new arr();
    a1.swap(arr,2,3);
    System.out.print(arr[2]);
    System.out.print(arr[3]);

}

}
class arr{

        public void swap(int[] arr,int i ,int j)
        {
            int temp= arr[i];
            arr[i]=arr[j];
            arr[j]=temp;

        }


}

封装

访问权限修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qdQhzTOn-1637223028136)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211104155852858.png)]

可以用来修饰类及其内部结构:属性,方法,构造器,内部类

修饰类(非内部类)只能用缺省和public

public class ss {
    public static void main(String[] args) {
        animal a1= new animal();
        a1.setName("大象");
        System.out.print(a1.getname());
    }
}
class animal{
    private String name;    //私有只能本类调用
    int legs;
    public void setName(String a)  //封装设置名字
    {
        name = a;
    }

    public String getname()   //封装获取名字
    {

        return name;
    }
}

构造器

constructor:

作用:

1.创建对象

2.初始化对象的属性

3.一个类中定义的多个构造器构成重载

说明:

1.如果没有显示的定义类的构造器的话,则系统默认提供一个空参的构造器.(但是如果定义了构造器则空参的构造器会被取消)

2.定义构造器的格式:权限修饰符类名(形参列表){ }

public class ss {
    public static void main(String[] args) {
        animal a1= new animal(5);     //创建对象且对属性初始化
        System.out.print(a1.getLegs());
    }
}
class animal{
    private String name;
    int legs;
    public int getLegs()
    {
        return legs;
    }
     public animal(int a)  //定义构造器
    {
        legs = a;
    }

}

构造器重载

public class ss {
    public static void main(String[] args) {
        animal a1= new animal(5);     //创建对象且对属性初始化
        System.out.print(a1.getLegs());
    }
}
class animal{
    private String name;
    int legs;
    public int getLegs()
    {
        return legs;
    }
           //构造器重载
     public animal()  //定义构造器
    {
    
    }
    public animal(int a)  //定义构造器
    {
        legs = a;
    }
    public animal(String i) //定义构造器
    {
        name=i;
    }
    public animal(String i,int a) //定义构造器
    {
        legs = a;
        name=i;
    }

}

属性赋值

4种方式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AtMCgQVl-1637223028137)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211104224924097.png)]

显式初始化就是在类里定义属性时赋值

javaBean

javaBean : 是一个公共类有一个无参构造器有属性且有对应的set和get方法

this

this:可以理解为当前对象调用属性方法和构造器

1.在类方法中使用this.属性或this.方法调用当前对象属性或方法但是通常选择省略,特殊情况下如果方法的形参和类的属性重名时我们必须使用this.变量的方式表名变量是属性而不是形参

   public static void main(String[] args) {
        animal a1= new animal(5);     //创建对象且对属性初始化
        System.out.print(a1.getLegs());
    }
}
class animal{
    private String name;
    int legs;
    public void setLegs(int legs)
    {
        this.legs=legs;      //形参与属性同名使用this
    }
    public animal(int legs)  //定义构造器
    {
        this.legs = legs;
    }
}

2.可以使用this( )调用本类中的构造器

并且构造器不能使用this调用自己(所以最多有n-i个构造器(n是构造器的个数))

class animal{
    private String name;
    int legs;
    public int getLegs()
    {
        return legs;
    }
    //构造器重载
    public animal()  //定义构造器
    {

    }
    public animal(int a)  //定义构造器
    {   this();
        legs = a;
    }
    public animal(String i) //定义构造器
    {
        this(6);
        this.name=i;
    }
    public animal(int a)  //定义构造器
        {   this("无敌");
        legs = a;
    }
    public animal(String i,int a) //定义构造器
    {
        this("");
        legs = a;
        name=i;
    }

}

p236 p237 p247

248-259

package

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-69kxvM0f-1637223028138)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211105130705165.png)]

import

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q24iAG6S-1637223028140)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211105130602002.png)]

面向对象中

继承

inheritance

好处:

较少冗余提高代码复用性

便于功能拓展

为多态性的使用提高了前提

继承性的格式

class A extends B

A:子类,派生类,subclass

B:父类,超类,基类,superclass

体现:

一旦子类A继承父类B以后,子类A就获得了父类B中声明的所有属性和方法;

父类中声明的私有属性和方法,子类继承父类后仍然获取了父类中的私有结构只是因为封装性影响使得子类不能直接调用父类结构而已(可以通过方法获取或设置)

子类继承父类后还可以声明自己的属性和方法实现功能拓展。

public class student extends Person //子类的声明
{
            int chengji;
            String hobbies;

    public student()
    {
    }

    public student(String name, int id, int age, int sex, int chengji, String hobbies) {
        super(name, id, age, sex);
        this.chengji = chengji;
        this.hobbies = hobbies;
    }

    public void learning(){
                System.out.print("我爱学习");
            }
}

java关于继承的规定

1.一个类可以被多个子类继承

2.一个子类只能有一个父类(单继承)

3.子父类是相对概念

4.子类直接继承的是直接父类,通过直接父类继承的父类是间接父类

5.子类可以继承直接父类和间接父类所有的属性方法;

Object类

1.如果没有声明父类,则此类继承于Java.lang.Object类

2.除Object类外,所有类都直接或间接继承于Object类

3.所有类都获得了Object类声明的功能

方法重写

在子类中对从父类中继承的方法进行改造,也称为方法的重置,覆盖

子类重写的方法的方法名和形参与父类的方法名和形参完全相同

特点:

子类方法重写后调用方法实际上是调用子类的方法
子类重写的方法的权限修饰符不能小于父类的方法
特殊情况:不能重写父类中声明为private的方法
.方法重写父类的方法声明不能是static
返回值类型
- 父类的方法返回值类型是void,子类的重写方法也必须是void的
- 父类的方法返回值类型是A,子类的重写方法返回值类型可以是A类也可以是A的子类
- 父类的方法返回值类型是基本数据类型(如double),子类的重写方法也必须是基本数据类型(double)

子类既可以重写父类方法也可以重载父类方法

super

理解为父类的

super调用属性方法

在子类方法或构造器使用
super.属性或super.方法表示调用父类的方法或属性,但通常省略不写
特殊情况:子类和父类有同名的属性必须写super(如果不写super则默认调用子类本身的属性)
子类重写父类方法,我们要使用父类方法我们要有super.方法名,表明调用父类方法

super调用构造器

在子类构造器在super(形参列表),调用父类中的构造器
super(形参列表)只能用在子类构造器的首行
构造器中this(形参列表)和super(形参列表)只能二选一
子类的构造器中默认调用了父类的空参构造器super( )

[ 如果父类写了构造器必须写空参构造器否则子类默认调用父类的空参构造器程序会报错 ]
子类构造器中至少有一个super调用的构造器

p279

多态

对象的多态性: 父类的引用指向子类的对象(子类的对象赋给在)

编写格式

父类对象名 = new 子类( );

    person s1= new man()

有了对象的多态以后,我们在编译期,只能调用父类中声明的方法,但在运行期,我们实际执行的是子类重写父类的方法

总结 编译(写)看左边,运行看右边

多态性的使用前提:

1. 类的继承关系2.要有方法的重写

对象的多态性只适用于方法不适用于属性

强制转换

1.父类对象强制转换成子类对象 (子类是包含父类的)

子类类型新的命名 = (子类类型)

2.是为了调用多态对象中右边new 的子类的特有方法

3.如果父类和子类有相同的属性名,强制转换为子类的对象后会优先就近调用子类的同名属性,如果没有同名属性则调用父类的

package com.atguigu.out.production.atguigu.java;


public class duotai {
    public static void main(String[] args) {
        person p1=new man(); //创建对象(对象的多态)  声明父类person类型但 new 子类man类型 
        
        p1.job();            //虚拟方法调用 p1调用的是man类重写后的方法(运行看右边)     输出挣钱养家  p1指向的堆空间具有子类和父类的属性和方法
                             //但不能调用子类特有的方法
                             
        p1.id=10000;            //子类和父类有同名的属性,通过多态创建的对象属性调用的是父类的属性,所以是给父类id赋值
    					     //属性是没有多态性的
    					     
        man m1=(man)p1;      //强制转换 将p1强制转换为man类型
        
        System.out.print(m1.id)//强制转换后优先在子类查找同名属性  输出 8
    }                        
}
class person{
    int id=10;
    private int age;
    private int sex;
    public person(int i, int i1){ };

    public person() {
        this.id = id;
        this.age = age;
        this.sex = sex;
    }
    public int getAge() {    //方法的封装
        return age;
    } 

    public void setAge(int age) {
        this.age = age;
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
    public void job(){
        System.out.print("挣钱");
    }
}
class man extends person{
    private int jobid;
    int id=8;
    public man(){
        super();
    }
    public void job(){
        System.out.print("挣钱养家");
    }


}

tostring重写

public String toString() {
    return "man{" +
            "jobid=" + jobid +
            '}';
}

包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GgKGyfrN-1637223028141)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211111103046611.png)]

转换的前提数值在转换前一定将要转换类型的正确类型数据

如string st1= "1234a"这个就没办法转换成int类型

如Boolean一定要是true或false的正确书写(Java严格区分大小写)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z7KlViLP-1637223028142)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211116083208447.png)]

自动装箱

基本数据类型转换为包装类

自动拆箱

包装类转换为基本数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VwcAK8Q1-1637223028143)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211116085335167.png)]

String类型

基本数据类型转换string

int num1 = 10;

方式一连接运算

String str = num1+"";

方式二:调用String的valueOf(Xxx xxx)

valueOf可以将包装类以字符串的形式取值

float f=12.3f;

String str2=String.valueOf(f1)//“12.3”

Double d1=new Double(12.4);

String str3 = String.valueOf(d1)//“12.40”

string转换基本数据类型

调用包装类的parseInt parseDouble parseBolean 等方法.

面向对象下

static

static使用

static:静态的
static可以用来修饰:属性,方法,代码块,内部类
使用static修饰属性:(静态变量或类变量)

static修饰的属性是类的所有实例对象共享的

只要类A更改了该static属性则B的该属性也被修改了

3.1 静态变量随着类的加载而加载

3.2 静态变量加载比对象创建早(没有对象之前就已经有静态变量了)

3.3通过类.属性的方式调用静态变量如 person.school

能否调用类变量 (静态变量) 实例变量
类能不能
对象能能
static修饰方法 (静态方法)

以下特点就是因为生命周期的问题因为static和类同时出生比实例类变量实力方法早

4.1 静态方法随着类的加载而加载

4.2 静态方法加载比对象创建早(没有对象之前就已经有静态方法了)

4.3通过类.属性的方式调用静态变量如 person.school

能否调用	类方法 (静态方法)	实例方法
类	能	不能
对象	能	能

4.4静态方法中只能调用静态方法,而非静态方法可以调用静态方法和非静态方法

4.5static方法中不能用实例变量和this 和super

5.如法中如何判别一个属性是否要声明为static

单例设计模式singleton

＜（＾－＾）＞某个类通过某种方式只能有一个实例对象

饿汉式

//在没调用时就new了一个对象
class single{
    private static single s1=new single();//设置为static是因为单例模只能有一个实例对象所以调用时不能再创建
    //为防止必须内部实例化唯一对象但外部需要调用对象就不能使用对象.的方式了,所以就用类.静态方法 的方式
    public static single getS1e(){//静态方法里只能调用静态属性,所以创建的唯一对象要设置静态
        return s1;
    }

}

懒汉式

//用时再new
class  single1{
    private static single1 s2=null;
    public static single1 getS2(){
        if(s2=null)
        {
            s2=new single1();

        }
        return s2;
    }
}

代码块

{ }

作用:用来初始化
只能用static修饰代码块
静态代码块

static{ }

随类的加载而加载

只能加载一次

作用:初始化类的信息

静态代码块只能调用静态的类属性类方法
非静态代码块

{ }

内部可以有输出语句

随着对象的创建而执行

每创建一次对象,就执行一次非静态代码块

作用:创建对象时,可以对对象的属性初始化

静态代码块非静态和构造器的执行先后顺序p332

方法体里有先后顺序(类里属性没有先声明先执行)

先静态其他看声明顺序

final

1.用来修饰类表示该类不能被继承

例如String类,System类,StringBuffer

final class man{

}

2.修饰方法:表明此方法不能被重写

3.修饰变量:表明此变量变为常量(属性也是变量的一种)

3.1 final修饰属性时可以对属性显式初始化也可以在代码块赋值,也可以在构造器赋值. (方法不能对final属性赋值因为如果创建对象了就已经有了默认值了,有了值常量就不能二次赋值了,所以要在对象没创建前赋值)

3.2 final修饰局部变量尤其final修饰局部变量中的形参时表明形参是在方法体内不能修改的

public void finalaA(final int id){

id=20;//在这里不能修改因为是final形参

return id+1;不是对id赋值所以是对的

}

static final 修饰属性称为全局常量

abstract

抽象的

1.abstract修饰类 :表示该类不能实例化

2.抽象类中必须有构造器供子类使用

3.抽象方法:用abstract修饰,

public abstract void eat( );

3.1只有方法声明没有方法体

3.2包含抽象方法的类一定是抽象类,抽象类可以有非抽象方法和抽象方法

3.3只有子类重写了直接和间接父类中所有的的抽象方法才可以初始化 (子类不重写父类的抽象方法,那子类也是抽象类)

4.注意事项

abstract不能用来修饰属性,构造器,不能修饰私有方法,静态方法,final方法,final类(以上都是因为子类不能重写抽象方法)

p346

匿名类

可以理解为:

抽象类例化+{ }

这样就创建出来了匿名子类

public class abstract1 {
    person p1=new person() {
        @Override
        void eat() {
            System.out.print("我是匿名类");
        }
    }
}

abstract  class person{
    private int id;
    public person(){

    }
    abstract void eat();
}
class man extends person{
    public man(){
        super();
    }
    @Override
    void eat() {
        System.out.print("我喜欢吃美食");
    }
}

p349模板练习

接口

p354练习

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E9tNuDYU-1637223028144)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211117232657577.png)]

接口可以理解为抽象类,接口里面方法是抽象方法,变量是全局变量static final

abstract  class person{//抽象类
    private int id;
    public person(){

    }
    abstract void eat();//抽象方法
}
class man extends person{
    public man(){
        super();
    }
    @Override
    void eat() {
        System.out.print("我喜欢吃美食");
    }
}


interface  finalss{//接口没有构造器,不能实例化

    public static final  double speed=7.9;//全局变量
    public abstract void start();//抽象方法
    int run();//省略的抽象方法
}
class studen extends person implements finalss {//实现类,必须对接口中的抽象方法重写才可以实例化
    @Override
    public void start() {

    }

    @Override
    public int run() {
        return 0;
    }

    @Override
    void eat() {//对父类中的抽象方法重写才可以实例化

    }
}

p358

1.jdk8也允许了接口中定义静态方法和默认方法

1.1.接口中的静态方法只能接口自己调用

1.2接口中的默认方法,实现类的实例对象可以调用

1.3调用接口中的默认方法"接口+super. 方法名"

2.如果实现类继承了的方法中在父类和接口中具有同名同参的方法,3那么实现类对象优先调用父类中的同名方法

3.实现类实现多个接口,多个接口中有同名同参的方法虽然冲突的不是抽象方法,但也必须方法重写(或者实现类的父类也具有该同名同参的方法)

class intertest{
    public static void main(String[] args) {
        finalss.sys();//接口中的静态方法只能接口自己调用
        studen s1=new studen();
        s1.defmed();//接口中的默认方法,实现类的实例对象可以调用
    }
}
class studen  implements finalss {//实现类
    @Override
    public void start() {
	finalss.super.defmed();//调用接口中的默认方法"接口+super. 方法名"
    }

    @Override
    public int run() {
        return 0;
    }

    
}

内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0rzXHJIH-1637223028145)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211118155140754.png)]

内部类实例化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jz3dlWF9-1637223028146)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211118114926247.png)]

内部类调用外部类的非静态属性,方法(重名时写外部类.this.属性名, 属性不重名直接写属性名就行)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCZu1DeZ-1637223028147)(C:\Users\mr.sun\AppData\Roaming\Typora\typora-user-images\image-20211118115203742.png)]

局部内部类(在成员方法中的类)

局部内部类调用成员方法中的局部变量,那么那个局部变量在成员方法中要定义为常量(就是用final修饰)

异常处理

}
class studen extends person implements finalss {//实现类,必须对接口中的抽象方法重写才可以实例化
@Override
public void start() {

}

@Override
public int run() {
    return 0;
}

@Override
void eat() {//对父类中的抽象方法重写才可以实例化

}

}


p358

1.jdk8也允许了接口中定义静态方法和默认方法

       1.1.接口中的静态方法只能接口自己调用

        1.2接口中的默认方法,实现类的实例对象可以调用

		1.3调用接口中的默认方法"接口+super. 方法名"

2.如果实现类继承了的方法中在父类和接口中具有同名同参的方法,3那么实现类对象优先调用父类中的同名方法

3.实现类实现多个接口,多个接口中有同名同参的方法虽然冲突的不是抽象方法,但也必须方法重写(或者实现类的父类也具有该同名同参的方法)

class intertest{
public static void main(String[] args) {
finalss.sys();//接口中的静态方法只能接口自己调用
studen s1=new studen();
s1.defmed();//接口中的默认方法,实现类的实例对象可以调用
}
}
class studen implements finalss {//实现类
@Override
public void start() {
finalss.super.defmed();//调用接口中的默认方法"接口+super. 方法名"
}

@Override
public int run() {
    return 0;
}

}


## 内部类

[外链图片转存中...(img-0rzXHJIH-1637223028145)]

内部类实例化

[外链图片转存中...(img-jz3dlWF9-1637223028146)]

内部类调用外部类的非静态属性,方法(重名时写外部类.this.属性名,  属性不重名直接写属性名就行)

[外链图片转存中...(img-NCZu1DeZ-1637223028147)]

局部内部类(在成员方法中的类)

			局部内部类调用成员方法中的局部变量,那么那个局部变量在成员方法中要定义为常量(就是用final修饰)

# 异常处理

苏薄

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础

Java基础文章目录Java基础标识符转义字符数据类型字符型布尔类型随机数分支结构if (表达式)switch(表达式 ){循环breakcontine数组一维数组二维数组静态初始化动态初始化方式一方式二错误的情况:调用数组里元素数组中的常见异常面向对象上成员属性(成员变量)成员方法形参,实参对象内存解析成员变量和局部变量return对象数组内存解析匿名对象方法重载(overload)可变个数形参的方法方法参数的值传递机制封装访问权限修饰符构造器作用:说明:构造器重载属性赋值javaBeanthispac
复制链接

扫一扫

专栏目录