Java教程

JAVA学习总结7.14

本文主要是介绍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方法.

多态:还没看捏。

构造器

构造器通常也叫构造方法、构造函数,构造器在每个项目中几乎无处不在。当你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的,它们不希望被其他任何外部的类访问。

这篇关于JAVA学习总结7.14的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!