JAVA学习总结7.14

目录

类和对象

构造器

API文档

方法重载

方法重写

this关键字

 四种不同权限修饰

---

---

类

类的成员变量的访问修饰符有public / protected / private 和缺省（不写访问修饰符）

• 如果缺省的话，那么这个变量只允许同一个包中的类访问，对其他包的类不可见，包括其他包的类的子类都不可见。
• public的话，则对所有的类都可见。
• protected的话，对本类，本包中的类，以及该类的所有子类可见。
• private的话，则只对本类可见。

开放性： public > protected > 缺省 > private

public class Puppy{    
    public Puppy(){                //无参构造方法
    }
    public Puppy(String name){     //有参构造方法
    }
}

类的三大特征：1、封装        2、继承        3、多态

封装：封装就是把同一类事物的共性（包括属性和方法）归到同一类中，方便使用。

特点：      

3.1 将变化隔离
3.2 便于使用
3.3 提高重用性
3.4 提高安全性

继承：多个类具有共同的属性（成员变量）与行为（成员方法）的时候，将这些共同的部分抽取出来定义到一个公共的类中，其他及各类可以与这个公共的类形成继承关系，从而在多个类中不需要重 复定义公共部分!这个公共的类就是父类，也称为超类或者基类，其他的类就是子类。子类可以直接访问父类的非私有化成员变量，访问父类的私有化成员变量可以使用super.get()方法。

特点：（1） 子类比父类强大
（2）java是单继承，不能进行多继承。但是可以继承多层子类（不建议继承超过3层）
（3）子类继承父类，但是对父类的成员变量是无法直接操作，只能通过父类继承过来的setter和getter方法.

多态：

多态是运行时行为

1、理解多态性：

一种事物的多种形态

2、什么是多态性：

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

3、多态的使用：虚拟方法调用

编译期，只能调用父类中的声明的方法，运行期执行的是子类重写父类的方法。简而言之编译看左边，运行看右边

4、多态使用前提：

1.类的继承。2.方法的重写

当产生随机方法时，无法观测到当前对象的指向，只有运行后才能知道该方法指向，编译时无法辨别

实际上就是子类重写父类的方法

内部类

内部类就是值类中包含的类

public class Out{    
    System.out.println("外部类"); 
    public class In{
         System.out.println("内部类"); 
    }
}

内部类的创建有两种方式

一：
Out out = new Out();
Out.In in = out.new In();
二：
Out.In in = new Out().new In();

内部类还有许多种不同种类的类比如私有内部类、静态内部类、方法内部类等

不过我还没看完捏。

构造器

构造器通常也叫构造方法、构造函数，构造器在每个项目中几乎无处不在。当你new一个对象时，就会调用构造器。构造器格式如下：

[修饰符，比如public] 类名 (参数列表，可以没有参数){
	//不能有return
}

其中修饰符将在后文提到  不同修饰符给予的权限不同其中public权限最高可以挎包访问而private权限最低只能在本类或构造器中使用

构造器也拥有一部分方法的特性如：继承、重载

API文档

Scanner类

引用类型的一般使用步骤：
1.导包
import 包路径.类名称；
如果要使用的目标类，和当前类位于同一个包下，可以省略导报语句不写。
只有java.lang 包下的内容不需要导包，其他的包都需要import语句。

例如

import java.lang.System;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;

2.创建
类名称 对象名 = new 类名称（）；
Scanner sc = new Scanner (System.in);
3.使用
对象名.成员方法名（）

获取键盘输入的一个int数字： int num = sc.nextInt();
获取键盘输入的一个字符串： String str = sc.next();        

    public static void main(String[] args){
       Scanner scanner=new Scanner(System.in);
       System.out.println("输入要求和的数");
        int n=scanner.nextInt();
        int result=sum(n);
        System.out.println(result);

    }

Random类

1.导包
import java.util.Random;
2.创建
Random r = new Random(); //小括号中可以留空即可
3.使用
1.获取一个随机的int数字（范围是int所有范围，有正负两种）： int num = r.nextInt();
2.获取一个随机的int数字（参数代表了范围，左闭右开区间）： int num = r.nextInt(3);
实际上代表含义是：[0,3) ,也就是0~2

 public static void main(String[] args) {
        Random r=new Random();
        for(int i=0;i<100;i++){
            int num=r.nextInt(bound 10);//范围实际上是0~9；
            System.out.println(num);
        }
}

ArrayList类
数组的长度不可以发生改变。
但是，ArrayList集合的长度是可以随意变化的。
对于Array List来说，有一个尖括号代表泛型。
泛型：也就是装在集合中的所有元素，全部都是统一的类型。
注意事项：对于ArrayList集合来说，直接打印得到的不是地址值而是内容。如果内容为空，得到的是空的中括号[ ];
在这里插入图片描述
ArrayList 当中常用的方法

public boolean add (E,e):向集合中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。

public E get(int index) : 从集合中获取元素，参数是索引编号，返回值就是对应元素位置。

public E remove(int index) : 从集合中删除元素，参数是索引编号，返回值就是被删除掉的元素。

public int size() : 获取集合的尺寸长度，返回值是集合中包含的元素个数。

Arrays类
java.util.Arrays 是一个与数组相关的工具类，里面提供了大量的静态方法，来实现数组的常见操作。
public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

Math类
java.util.Math类是数学想的工具类

public static double abs(double num)：获取绝对值，有多种重载
public static double ceil(double num)：向上取整
public static double floor(double num)：向下取整
public staticlong round(double num)：四舍五入
Math.PI代表π。

方法重载

定义：在一个类中有两个方法，他们具有相同的名字，但有不同的参数列表。

也就是说，方法名（等同于函数名）可以相同，只要保证形参类型不同就可以了

特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类 型)。调用时，根据方法参数列表的不同来区别。

例如：

package java_testquestions;
public class Array_average 
{
	public static int average(int[] array)
	{
		int i,sum=0;
		for(i=0;i<=array.length-1;i++)
		{
			sum+=array[i];
		}
		return sum;
	}
	public static double average(double[] array)
	{
		int i;
		double sum=0;
		for(i=0;i<=array.length-1;i++)
		{
			sum+=array[i];
		}
		return sum;
	}
	public static void main(String[] args)
	{
		System.out.println("请输入10个 数据：");
		int i;
		int[] mylist1 = {11,12,13,14,15,16,17,18,19,20};
		double[] mylist2 = {11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0};
		System.out.println("int 类型调用数值："+average(mylist1));
		System.out.println("double 类型调用数值："+average(mylist2));
	}
}

当执行average方法时，系统会自动识别（）中的数据类型自行选择方法进行操作。

有利于减少代码量，增加代码重复利用率。

方法重写

定义：重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类）

作用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

简而言之就是对基本相同功能的方法的整合，对各自特有的内容保留。

重写规定：

方法申明：

权限修饰符 返回值类型 方法名（参数列表）{

//方法体

}

子类中称为重写的方法 父类中称为被重写的方法

1、子类重写的方法名和形参列表与父类被重写的相同

2、子类重写的权限修饰符权限不小于父类

3、子类不能重写父类中的private权限的方法

4、父类中方法返回值为void 则子类中重写后的返回值也只能为void

返回类型为A类型，则子类方法返回类型只能为A类或A的子类；

返回类型为基本类型，则子类方法返回类型必须为基本类型（int、double）

重写与重载的区别：

重写需要在继承时才能使用，所以是子类重写父类方法（子类的返回类型、方法名、参数、修饰符都与父类的方法一致）

重载是在同一个类中多个同名函数的不同参数的选取调用生成了不同形参的方法（于返回类型，修饰符无关）

重载一个类 重写两个类

重载在编译器就已经绑定了调用地址，称为早绑定或静态绑定

this关键字

指向当前对象的引用               访问类中的成员变量，区分成员变量与局部变量（重名问题）

public class ThisDemo {
        public static void main(String[] args) {
            Student s=new Student("小明明",20);
            System.out.println(s);
        }
    }
    class Student{
        String name;
        int age;
        public Student(String name, int age) {
            name = name;//前者name与后者name为成员变量与局部变量  未加this
            age = age;
        }
        @Override
        public String toString() {
            return "Student [ name=" + name + ", age=" + age +"]";
        }
    }

 打印结果：

打印结果:Student [ name=null, age=0]
赋值没有成功,说明:name(局部变量)=name(局部变量);
而不是name(成员变量)=name(局部变量);

public Student(String name, int age) {
        this.name = name;    //用this进行区分成员变量和局部变量
        this.age = age;
}

打印结果:Student [ name=小明明, age=20]
这样子就赋值成功啦

 super关键字       

作用：

1、调用父类被子类重写的方法；

2、调用父类被子类重定义的字段（被隐藏的成员变量）；

3、调用父类的构造方法；

public class Person {
    public Person(String name, int age) {
    }
    public Person(String name, int age, String sex) {
    }
}
public class Student extends Person {
    public Student(String name, int age, String birth) {
        super(name, age); // 调用父类中含有2个参数的方法
    }
    public Student(String name, int age, String sex, String birth) {
        super(name, age, sex); // 调用父类中含有3个参数的方法
    }
}

super和this的区别

与重载和重写相似

super作用于两个类中的，父类和子类

this调用的是一个类中的属性、方法、对象的

两者都不能出现在static关键字修饰的方法中

Static

定义：在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

直接从例题感受

public class Test extends Base{

    static{
        System.out.println("test static");
    }

    public Test(){
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new Test();
    }
}

class Base{

    static{
        System.out.println("base static");
    }

    public Base(){
        System.out.println("base constructor");
    }
}

输出结果为

base static
test static
base constructor
test constructor

过程：

找到main方法入口，在执行main方法之前，先加载Test类

加载Test类的时候，发现Test类继承Base类，于是先去加载Base类

加载Base类的时候，发现Base类有static块，而是先执行static块，输出base static结果

Base类加载完成后，再去加载Test类，发现Test类也有static块，而是执行Test类中的static块，输出test static结果

Base类和Test类加载完成后，然后执行main方法中的new Test()，调用子类构造器之前会先调用父类构造器

调用父类构造器，输出base constructor结果

然后再调用子类构造器，输出test constructor结果

四种不同权限修饰

public：

具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。

protected：

主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西

default：

有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。

private：

访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

abstract抽象类

抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰，同时不能有new对象。

简而言之就是一个父类有多个子类，而每个子类对父类的方法都有各自的定义和强大之处，此时父类就可以不用创建具体的方法，只需要继承给子类方法就行。

抽象类

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}