首页 > 编程语言> > JAVA学习总结7.14

JAVA学习总结7.14

2021-07-14 22:05:16 作者：互联网

类

API文档

类

类的成员变量的访问修饰符有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方法.

多态：还没看捏。

构造器

构造器通常也叫构造方法、构造函数，构造器在每个项目中几乎无处不在。当你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方法时，系统会自动识别（）中的数据类型自行选择方法进行操作。

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

方法重写

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

作用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。简而言之就是对基本相同功能的方法的整合，对各自特有的内容保留。

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]
这样子就可以赋值成功啦

四种不同权限修饰

public：

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

protected：

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

default：

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

private：

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

标签：7.14,总结,JAVA,name,int,子类,age,父类,public
来源： https://blog.csdn.net/Dankate/article/details/118735053