java基础复习（二）-CSDN博客

本文链接：https://blog.csdn.net/weixin_55782195/article/details/119594343

一、方法

1.1 方法的定义

方法的声明格式：

修饰符返回值类型方法名（参数类型形参1, 参数类型形参2, ….）｛
方法体程序代码
return 返回值;
｝

其中：

修饰符：public,缺省,private, protected等

返回值类型：

没有返回值：void。
有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用

方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”

形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开

形参：用来定义作用的
实参：实际调用传递给它的参数
形参和对应的实参的参数类型必须一致。

返回值：方法在执行完毕后返还给调用它的程序的数据。


public String sayHello(){
return "hello,word";
}

1.1.1 break和return的区别

break跳出switch，结束循环。
return 结束方法，返回一个结果（结果可以为空）。

1.2 重载

方法的重载（overload）:在同一个类中，允许存在一个以上的同名方法，只要他们的参数列表不同即可。

”两同一不同“：同一个类、相同方法名
参数列表不同( 参数排列顺序不同，参数个数不同，参数类型不同)

如下四个方法构成了重载:

public class overload{
      
 public void getSum(int i,int j){
     Ststem.out.println(i+j);
}
  public void getSum(double d1,double d2){
        
}
  public void getSum(String s,int i){
          
}
//方法四与方法三的参数顺序不同，可以构成重载
  public void getSum(int i,String s){
        
}
}

如下四个方法不构成重载:

 public void getSum(int i,int j){
}
//与方法一形参变量名不相同，但形参列表相同，不构成重载
 public void getSum(int m,int n){
}
//与方法一返回值类型不同，但形参列表相同，不构成重载
 public int getSum(int i,int j){
}
//与方法一权限修饰符不同，但形参列表相同，不构成重载
private void getSum(int i,int j){
}

二、初识面向对象（OOP）

2.1 类和对象

类(Class)和对象(Object)是面向对象的核心概念。
类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)

2.2 面向对象与面向过程（理解)

面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。
面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

2.3 使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
使用new 关键字，本质是调用构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
并且构造器有以下两个特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void

构造器作用：
1、实例化初始值

public class Person{
String name;
//无参构造
public Person(){

}
//有参构造，一旦定义有参构造，无参构造必须显示定义
//this.值：代表当前类的值
public Person(String name){
this.name=name;
}
}
*****************************
public class Demo{
public static void main(String [] args){
//new 实例化一个对象
Person person=new Person();
System.out.println(person.name);//null
//有参
Person person=new Person("java");
System.out.println(person.name);//java
}
}

三、面向对象三大特性

3.1 封装

程序设计要追求”高内聚，低耦合”
●高内聚就是类的内部数据操作细节自己完成，不允许外部
干涉;
●低耦合:仅暴露少量的方法给外部使用。

封装(数据的隐藏)
通常, 应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
即属性私有, get/set。

package OOP;

public class Student {
   //属性私有
   private String name;
   private int age;
   private char sex;
//get 获得数据
//set 给数据设置值
    
    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

package OOP;

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("hello");
        System.out.println(s1.getName());//hello
    }
}

封装的作用
1、提高程序的安全性、保护数据
2、隐藏代码实现细节
3、统一接口
4、系统可维护性增加了

3.2 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是"扩展”。子类是父类的扩展。

◆JAVA中类只有单继承，没有多继承!
◆继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
◆继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

子类继承父类就会拥有父类的所有方法
私有的属性无法被直接继承

package OOP;
//父类
//在Java中，所有的类都默认直接或者间接继承Object
public class Person {
 private double money=100000;
    public void say(){
        System.out.println("说话");
    }


}
//*************************************************
package OOP;
//子类 派生类
//子类继承父类就会拥有父类的所有方法
public class Student extends Person {
}
//**************************************************

package OOP;

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
          s1.say();//说话
        //私有的属性无法被直接继承,需要调用get方法获得
          s1.money;//报错
    }
}

object类
在Java中，所有的类都默认直接或者间接继承Object

3.2.1 super

注意点：
1、super调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法

super和this的不同：

代表的对象不同：

this:本身调用这个对象
super:代表父类对象的应用

前提:

this:没有继承也可以使用
super:只能在继承条件才可以使用

构造方法:

this() ; 本类的构造
super():父类的构造

package OOP;
//父类
public class Person {
protected String name="hello";

public Person(){
    System.out.println("Person无参构造");

}   
}

package OOP;
//子类 派生类
public class Student extends Person {

    private String name="hi";

    public Student(){
        //隐藏代码：调用父类的构造器
        super();//调用父类的构造器，必须在子类的第一行
        System.out.println("Student无参构造");
    }
    public void test(String name){
        System.out.println(name);//传入的参数name
        System.out.println(this.name);//子类(当前类)的name
        System.out.println(super.name);//父类的name

    }
}

package OOP;

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
         s1.test("java");
    }
}

Person无参构造
Student无参构造
java
hi
hello

3.2.2 方法重写

前提：需要有继承关系，子类重写父类方法

定义：
在子类中可以根据需要对父类中继承来的方法进行改造，也称为方法的重置、覆盖。在执行程序时，子类的方法可以覆盖父类的方法。

子类继承父类后，可以对父类中同名、同参数的方法，进行覆盖操作

2.要求

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

父类被重写方法的方法的返回值类型是void,则子类重写方法的返回值类型只能是void
父类被重写方法的方法的返回值类型是A类,则子类重写方法的返回值类型可以是A类或A类的子类
父类被重写方法的方法的返回值类型是基本数据类型（比如：double）,则子类重写方法的返回值类型只能是相同的基本数据类型(必须也是double)

子类重写的方法的使用的访问权限不能小于父类被重写的方法的访问权限

子类方法抛出的异常不能大于父类被重写方法的异常

注意：
父类与子类中同名、同参数的方法必须同时声明为非static的（即为重写），或者同时声明为static（不是重写）。因为static方法属于类的，不属于实例，子类无法覆盖父类的方法。

package OOP;
public class B {
//静态方法
    public static void test(){
        System.out.println("B=>test");
    }
    //非静态方法
     public  void test1(){
        System.out.println("B=>test");
    }
}

package OOP;

public class A extends B{
    public static void test(){
        System.out.println("A=>test");
    }

    @Override
    public void test1() {
        System.out.println("A=>test");
    }
}

package OOP;

public class Application {
    public static void main(String[] args) {
//        Student s1=new Student();
//         s1.test("java");
        A a=new A();
        a.test();//A=>test
        a.test1();//A=>test

        //父类的应用指向子类
        B b=new A();//子类重写了父类的方法
        b.test();//B=>test
        b.test1();//A=>test

    }
}

3.3 多态

◆即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
◆一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：继承、重写、向上转型
◆有继承关系
◆子类重写父类方法
◆父类引用指向子类对象(子类重写父类的方法，执行子类的方法)

注意:多态是方法的多态，属性没有多态性。

package OOP;
//父类
public class Person {
    public void say(){
        System.out.println("说话");
    }
 public void run(){
        System.out.println("run");
    }

}

package OOP;
//子类 派生类
public class Student extends Person {

    @Override
    public void say() {
        System.out.println("student说话");
    }
    public void eat(){
        System.out.println("eat");
    }
}

package OOP;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了
        //Student能调用的方法都是自己或继承父类的
        Student s1=new Student();
        //父类的引用指向子类
        //Person父类型可以指向子类，但不能调用子类独有的方法
        Person s2=new Student();
        Object s3=new Student();

        //对象执行哪些方法，主要看对像左边的类型，和右边关系不大
        s1.run();//run//Student能调用的方法都是自己或继承父类的
         s2.run(); //run       
        s1.say();//student说话
        s2.say();//student说话 //子类重写父类的方法，执行子类的方法
         s2.eat();//报错，父类型可以指向子类，但不能调用子类独有的方法
    }
}

3.3.1 instanceof（类型转换）

1、父类引用指向子类的对象
2、把子类转化为父类，向上转型
3、把父类转化为子类，向下转型
4、方便方法的调用，减少重复代码，简洁

System.out.println(x instanceo y);//编译是否通过要看x与y是否存在继承关系，x是y的子类型

  Person s2=new Student();
  ((Student) s2).eat();//将Person类转化成Student类型，既可以使用子类独有的方法

补充点：

package OOP;

public class Person {
    //执行顺序2    匿名代码块
    {
        System.out.println("匿名代码块");
    }
    //执行顺序1  只执行一次
static {
    System.out.println("静态代码块");
}
//执行顺序3
public Person(){
    System.out.println("构造方法");
}

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("===========");
        Person person2 = new Person();
    }
}

静态代码块
匿名代码块
构造方法
===========
匿名代码块
构造方法

Process finished with exit code 0

四、抽象类和接口

4.1 抽象类

◆abstract修饰符可以用来修饰方法也可以修饰类如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

◆抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。

◆抽象方法，只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类那么就必须要实现抽象类没有实现的抽象方法否则该子类也要声明为抽象类。

package OOP;

public  abstract  class Action {
  //抽象方法，只有方法名字，没有方法的实现
    public abstract void dosomething();
}

package OOP;
//抽象类的所有方法，继承了它的子类，都必须要实现他的方法
public class A extends Action {
    @Override
    public void dosomething() {
        System.out.println("abstract");
    }
}

4.2 接口

接口的使用
1.接口使用interface来定义
2.在java中接口和类是两个并列的结构

接口中不能定义构造器，意味着接口不可以实例化,接口都需要实现类。
java开发中，接口通过让类去实现（implements）的方式来使用

如果实现类覆盖了接口中所有的抽象方法，那么这个类可以实例化
如果实现类没有覆盖了接口中所有的抽象方法，那么此实现类仍是一个抽象类
java类可以实现多个接口------>>弥补了Java类的单继承的局限性
格式：class A extends B implements C,D,E
接口与接口之间可以多继承

请添加图片描述
什么时候使用抽象类和接口:
如果拥有一些方法并且想让它们中的一一些有默认实现，使用抽象类。
如果想实现多重继承，必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。
如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

五、内部类

内部类就是在一个类的内部在定义一·个类，比如，A类中定义一·个B类,那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

package OOP;

public class outer {
    private int id=19;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
    }
}

package OOP;

public class Application {
    public static void main(String[] args) {
        outer outer = new outer();
       //通过外部类创建内部类
        OOP.outer.Inner inner = outer.new Inner();
         inner.getId();//19
    }
}

六、异常机制

◆Java把异常当作对象来处理,并定义- -个基类java.lang.Throwable作为所有异常的超类。
◆在Java API中已经定义了许多异常类,这些异常类分为两大类，错误Error和异常Exception。
◆在Exception分支中有一个重要的子类RuntineException (运行时异常)

ArraylndexOutOfBoundsException (数组下标越界)
NullPointerException (空指针异常)
ArithmeticException(算术异常)
MissingResourceException (丢失资源)
ClassNotFoundException (找不到类)等异常,这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

异常处理的五个关键字
try、catch、finally、throw、throws

基本语法：
捕获异常：

try{//try监控区域
可能发生异常的代码
}catch（想要捕获的异常类型）{
//catch捕获异常
}finally{
//无论代码发生异常，代码必定执行
}

throw扔的是异常对象，常用在方法中：

例如：
int result(){
if(b==0){
throw扔异常对象; throw new Exception
}
return …;
}

public int result(){
int a=1;
int b=0;
try{
if(b==0){
throw new ArithmeticException();//主动抛出异常,一般在方法中使用
 }
 return a/b;
}

如果在一个方法内无法处理抛出异常，则在方法上抛出异常

使用throws抛出异常
void fun throws 异常类{
}

public void test(int a,int b)throws ArithmeticException{
if(b==0){
throw new ArithmeticException();
  }
 }