Arrays工具类||继承
Arrays常见操作
/*工具类,一个与数组相关的工具类,里面提供了大量静态方法,用来实现数组常见的操作
* public static String toString(数组):将参数数组变成字符串[1,2,3]
* public static void sort(数组):排序,默认升序*/
public class Arrays1 {
public static void main(String[] args) {
int[] intarray={1,2,3,4};
System.out.println(intarray);//
String intStr = Arrays.toString(intarray);
System.out.println(intStr);//[1,2,3,4]
int[] a1 = {2,13,41,32,2};
Arrays.sort(a1);
String intStr1 = Arrays.toString(a1);//[2, 2, 13, 32, 41]
System.out.println(intStr1);
}
}
将一个随机字符串中的所有字符升序排列,并倒序打印。
public class Arrays2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.next();//键盘输入字符串
char[] ch =str.toCharArray();// 该方法的作用是返回一个字符数组,该字符数组中存放了当前字符串中的所有字符
Arrays.sort(ch);
sortF(ch);
}
public static void sortF(char[] s){
for (int i = s.length-1; i>=0; i--) {
System.out.println(s[i]);
}
}
}
Math操作
public static double abs(double num):获取绝对值
public static double ceil(double num):向上取整
public static double floor(double num):向下取整
Math.PI圆周率 常量
public class Math1 {
public static void main(String[] args) {
//获取绝对值
System.out.println(Math.abs(3.14));//3.14
System.out.println(Math.abs(0));//0
System.out.println(Math.abs(-2.5));//2.5
//向上取整
System.out.println(Math.ceil(11));//11.0
System.out.println(Math.ceil(3.9));//4.0
System.out.println(Math.ceil(-2.4));//-2.0
//向下取整
System.out.println(Math.floor(3.1));//3.0
System.out.println(Math.floor(-3.1));//-4.0
System.out.println(Math.floor(11));//11.0
//四舍五入
System.out.println(Math.round(20.4));//20
System.out.println(Math.round(10.5));//11
}
}
计算在-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个?
public class MathPractice {
public static void main(String[] args) {
getSum(-10.8,5.9,6,2.1);
}
public static void getSum(double a,double b,int c,double d){
int sum =0;
for(int s=(int)a;s<=b;s++){//这里a是double,转成int型,方便计算整数
if(Math.abs(s)>c||Math.abs(s)<d){
sum=sum+1;
}
}
System.out.println(sum);
}
}
继承
Java语言是单继承的,一个子类只能有一个父类,但是可以多级继承A extends B,B extends C。
/*继承
* 父类、基类、超类
* 子类、派生类
* 子类可以拥有父类的内容还可以拥有自己的
* 在继承的关系中,子类就是父类,教师就是员工。*/
创建Employee类
public class Employee {
private String name;
private int age;
int numFu =10;
int num=2000;
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 static void getSalary(){
System.out.println("发工资");
}
}
创建Teacher类
public class Teacher extends Employee{
int numZi=20;
public void print(){
System.out.println(num);
}
}
public class Extends {
public static void main(String[] args) {
Teacher t1 = new Teacher();
Employee e1= new Employee();
e1.setAge(10);
e1.setName("fang");
t1.setAge(12);
t1.setName("wen");
System.out.println(t1.getAge());//12
System.out.println(t1.getName());//wen
System.out.println(e1.getAge());//10
System.out.println(e1.getName());//fang
System.out.println(t1.numFu);//10
System.out.println(e1.numFu);//10
System.out.println(t1.numZi);//20
t1.print();//2000,继承父类的num
}
}
/*区分子类中方法重名的三种
局部变量: 直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量: super.成员变量名
* */
自己测试,快把自己绕晕了,刚学习正好看看自己的逻辑。
public class Extends1 {
public static void main(String[] args) {
Zi z = new Zi();
z.method();
z.method1(10);
Zi z1 = new Zi();
z1.method1(1);
}
}
class Fu{
int num = 10 ;
public void method0(){
System.out.println("父类的nethod");
}
}
class Zi extends Fu{
int num = 20;
public void method0(){
System.out.println("子类的method");
}
public void method(){
int num = 30;
System.out.println(num);//30 局部变量
System.out.println(this.num);//20 this本类的num
System.out.println(super.num);//10 super父类的num
method0();//子类的method
super.method0();//父类的nethod
this.method1(20);//静态的直接访问
}
public static void method1(int ab){//非静态的,没有static修饰,需要创建对象才能访问
Zi zi =new Zi();
int a = zi.num;
int c = ab;
System.out.println(a);//20
System.out.println(c);
}
public static void method2(int ab){//非静态的,没有static修饰,需要创建对象才能访问
Zi zi =new Zi();
int a = zi.num;
int c = ab;
System.out.println(a);//20
System.out.println(c);//
//method1(20);
//zi.method();
}
}
/*继承关系中,父子类构造方法的访问特点
*
* 1子类构造方法中有一个默认隐含的super()调用
* 可以通过super关键字来子类构造调用父类重载构造super(arg);
* super的父类构造器调用,必须是子类构造方法中的第一个语句**/
public class Constractor {
public static void main(String[] args) {
Z1 z = new Z1();
z.fun1();//子类中没有fun1(),继承父类的fun1();
}
}
class F1{
public F1(){
System.out.println("父类的");
}
public F1(int num){
System.out.println(num+"父类重载的构造方法");
}
public void fun1(){
System.out.println("方法1");
}
}
class Z1 extends F1{
public Z1(){
//super();//在调用父类的无参构造方法
super(10);//10父类重载的构造方法
System.out.println("子类的");
//super();//必须放在第一个语句,只能调用一个构造方法
super.fun1();//方法1
}
}