java总结（2）

编程入门行业动态更新时间:2024-10-24 17:31:09

java总结（2）

(60条消息) Java文件操作（超详细+代码示例）_Gorit的博客-CSDN博客_java文件操作

趣味：(63条消息) int与Integer的区别及Integer的缓存机制、Integer.valueOf方法的使用_Hamoy的博客-CSDN博客

小数进行位运算：

import java.util.Scanner;//Scanner类表示简单文本扫描器，在Java.util包
public class Hello{public static void main(String[] args){Scanner myScanner = new Scanner(System.in);//接受用户输入，使用相关方法System.out.println("please input :");String name=myScanner.next();//接受用户输入System.out.println("please input :");int age=myScanner.nextInt();}
}

文件一般都存放在硬盘中，在上世纪还会存储在光驱还有软盘等等

public class Hello{public static void main(String[] args){//使用00P面向对象解决//实例化一只猫[创建一只猫对象]//1. new Cat() 创建一只猫// 2.new Cat1=new Cat(); 把创建的猫赋给cat1Cat cat1= new Cat();cat1.name="qwe";cat1.age=12;// 3.new Cat2=new Cat(); 把创建的猫赋给cat2Cat cat2= new Cat();cat2.name="asd";System.out.println(cat1.name+cat1.age);}
}
//使用面向对象的方式来解决养猫问题   定义一个猫类Cat->自定义的数据类型
class Cat{//属性String name;//名字int age;//年龄String color;//颜色//行为
}

同一个类中方法可以直接调用：

public class Hello{public static void main(String[] args){A a= new A();a.sayok();}
}
class A{public void print(){System.out.println("-->print()");}public void sayok(){print();System.out.println("-->sayok()");}
}

跨类调用：

public class Hello{public static void main(String[] args){A a= new A();a.sayok();}
}
class A{public void print(){System.out.println("-->print()");B b=new B();b.f1();}public void sayok(){print();System.out.println("-->sayok()");}
}
class B{public void f1(){System.out.println("-->f1()");}
}

克隆对象：

public class Hello{public static void main(String[] args){Person p=new Person();p.name="Zoey";p.age=18;MyTools tool= new MyTools();Person p2= tool.f1(p);System.out.println(p.name+p.age);System.out.println(p2.name+p2.age);}
}
class Person {String name;int age;
}
class MyTools{public Person f1(Person p){Person p2= new Person();p2=p;return p2;}
}

当函数名相同，类型也都相同的时候，错误：

可变参数的使用：

public class Hello{public static void main(String[] args){he a= new he();System.out.println(a.f1(1,2,3,4,5));}
}
class he{//1、 int...表示接受的是可变参数，类型是int,即可以接收多个int(0~多)//2、 使用可变参数时，可以当作数组来使用 即 nums 可以当成是数组//3、遍历 nums 求和public int f1(int ... nums){int s=0;for(int x:nums){s+=x;}return s;}
}

//细节：可变参数可以和普通参数类型的参数一起放在形参列表，但必须保证可变参数在最后public void f2(String str,double... nums){}

//细节： 一个形参列表中只能出现一个可变参数//错误public void f3(int ...nums1, double ... nums2){}

作用域的使用：

public class Hello{public static void main(String[] args){Person a= new Person();a.f1();T aa = new T();aa.test();}
}
class T{//通过对象调用使用其他类的属性public void test(){Person p= new Person();System.out.println(p.name);}
}
class Person{String name="jack";public void f1(){Person p=new Person();System.out.println(p.name);}
}

public class Hello{public static void main(String[] args){Person a= new Person();a.f1();T aa= new T();aa.test2(a);}
}
class T{public void test2(Person p){     System.out.println(p.name);}
}
class Person{String name="jack";public void f1(){Person p=new Person();System.out.println(p.name);}
}

构造器的本质是方法，构造器也可以重载

public class Hello{public static void main(String[] args){Person p1= new Person("Zoey",18);System.out.println(p1.name+p1.age);}
}
class Person{String name;int age;//构造器//1、构造器没有返回值，也不能写void//2、构造器的名称和类Person一样（必须一样）//3、(String Pname,int Page)是构造器的形参列表，规则和成员方法一样public Person(String Pname,int Page){name=Pname;age=Page;}
}

public class Hello{public static void main(String[] args){A aa=new A("abd");System.out.print(aa.name+aa.age);}
}
class A{String name;int age=4;public A(){   //显示无参构造    无参构造器是默认的，但是当定义了带构造器后，无参构造器就被覆盖了，所以若想要的话   就要再定义一次 显示出来age=18;}public A(String pname){  //带参构造器name=pname;}
}

Java虚拟机会给每一个对象分配 this 代表当前对象

哪个对象调用， this 就代表哪个对象

public class Hello{public static void main(String[] args){T t=new T();}
}
class T{/*细节：访问构造器语法： this(参数列表)  必须放置第一条语句注意只能在构造器中使用（即只能在构造器中访问另外一个构造器）*/public T(){  //无参构造器this("jack",100);System.out.println("T()");}public T(String name,int age){System.out.println("T(String name,int age)");}
}

public class Hello{public static void main(String[] args){T t=new T();t.f();}
}
//this 关键字可以用来访问此类的属性
class T{String name="smith";int age=100;public void f(){  //无参构造器String name="jack";System.out.println(name+age);  //jack 100   //有局部变量就按就近原则System.out.println(this.name+this.age);  // smith 100}
}

//题目，比较 p1,p2是否全都相等
public class Hello{public static void main(String[] args){Person p1=new Person("abc",18);Person p2= new Person("qwe",12);System.out.println("p1和p2比较的结果:"+p1pareTo(p2));}
}
class Person {String name;int age;public Person(String name, int age) {//构造器this.name = name;this.age = age;}public boolean compareTo(Person p) {return this.name.equals(p.name)&&this.age==p.age;}
}

//无参方法：
public void f(){}// 无参构造器
public T(){     //（T 与类名一样）}     //带参方法  
public void f(String name,int age){}   // 带参构造器
public T(String name,int age){}

Java.io包

现在大家看到 “i/o” 想必也不会陌生了吧，这是Java中一个内置的包，专门用于文件读写的一个操作的类
在程序中使用文件或者流的操作就要导入import java.io.*;(61条消息) java中import作用详解_一支纯牛奶的博客-CSDN博客_import java

一、包的作用：

1.区分相同名字的类

2.当类很多的时候可以很好的管理类

3.控制访问范围

二、包的基本语法： package com.hspedu;

1.package 关键字，打包名.

2.hspedu:表示包名

封装就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。

对数据进行验证就像age=1200,没人能活那么久，所以就需要进行判断

setter和getter的快捷键 Alt + insert;

继承来解决代码复用性，当多个类存在相同的属性[变量]和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extend来声明继承父类。

继承的基本语法： class 子类 extends 父类{ }

1.子类就会自动拥有父类定义的属性和方法

2.父类又叫超类和基类

3.子类又叫派生类

继承的作用：

1.提高代码的复用性

2.提高代码的扩展性和维护性

1.父类中非私有的属性和方法可以在子类直接访问，但是私有的不行。

2.子类必须调用父类的构造器，完成父类的初始化

3.当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器去完成对父类的初始化工作，否则，编译不会通过。

注意注意：super 只能在构造器中使用，并且必须放在构造器的第一行

super()和this()都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器里

注解：构造器中this()表示调用形式参数相同的同一个类中的另一个构造器
public class Hello {public  static void main(String[] args) {// A a=new A("smith");B b=new B("jack");}
}
class A{public A(String name){ // 父类的有参构造器System.out.println("A()...."+name);}
}
class B extends A{public B(String name){  //子类的有参构造器//super();//默认调用父类的无参构造器  可写可不写，默认存在super("jack"); //当父类没有无参构造器时，就必须要指定调用父类的哪一个构造器System.out.println("B()....");}
}
object时所有类的基类（父类）。

父类构造器的调用不仅限于直接父类，而是一直往上追溯直到object(顶级父类)。

例：如果farther中：private int age; 那么kig想要获取age的话就要在farther中使用public int getAge(){return age;}

extends 例题：

public class Hello {public  static void main(String[] args) {pc cc=new pc("intel",16,500,"IBM");cc.printinfo();}
}class computer {private String cpu;private int memory;private int disk;public computer(String cpu,int memory,int disk){  //带参构造器this.cpu=cpu;this.memory=memory;this.disk=disk;}public String getDetails(){return "cpu="+cpu+" memory="+memory+" disk="+disk;}public String getCpu() {return cpu;}public void setCpu(String cpu) {this.cpu = cpu;}public int getMemory() {return memory;}public void setMemory(int memory) {this.memory = memory;}public int getDisk() {return disk;}public void setDisk(int disk) {this.disk = disk;}
}
class pc extends computer{private String brand;public pc(String cpu,int memory,int disk,String brand){super(cpu,memory,disk);this.brand=brand;}public String getBrand(){return brand;}public void setBrand(String brand){this.brand=brand;}public void printinfo(){System.out.println("PC：  "+getDetails()+" brand="+brand);}
}

super关键字: 代表父类的引用，用于访问父类的属性、方法、构造器，但是super访问不了private属性和private方法，访问父类构造器时必须放在构造器的第一句，而且只能出现一句
class A{public int a=1;private int b=2;protected int c=3;int d=4;
}
class B extends A{public void hi(){System.out.println(super.a);System.out.println(super.b);//错误，不能访问父类私有的属性或方法System.out.println(super.c);System.out.println(super.d);}
}
class A{   //A类  父类}
class B extends A{   // B继承A 子类public B(){   //构造器super();  // 置于构造器的第一句，访问父类A的无参构造器System.out.println();}public void hi(){    //方法super();  //super只能放在构造器里，不能置于方法里}
super调用父类构造器的好处：分工明确，父类属性由父类初始化，子类属性由子类初始化。

当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员必须通过super，当没有重名时，使用super、this、直接访问是一样的效果。

假设C继承B，B继承A，当在C中调用一个方法时：（属性与方法一致）

（1）.先找本类，如果有，则调用

（2）.如果没有则找父类（若有且可以调用，则调用）

（3）.若没有，则找父类的父类......直到object

提示：若在查找的过程中找到了但是不能访问则报错（cannot access），若没找到则提示方法不存在。

假设方法名为cal 则：this.cal() 等价于cal

super.cal()的顺序是直接查找父亲类，其他的规则一样

super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以用super去访问爷爷类的成员，如果多个基类（上级类）都有同名成员则super遵循就近原则 C -> B -> A

方法重写/覆盖（override）:子类有一个方法和父类的某个方法的名称、返回类型、参数一样那么我们就说子类的这个方法覆盖了父类（所有上级）的那个方法。

子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类，比如：父类的返回类型是Object,子类方法返回类型是String
class A{   //A类  父类public void f(){System.out.println("A-->f()");}
}
class B extends A{   // B继承A 子类public void f(){   //名称、返回值、参数都一样  构成方法重写System.out.println("B-->f()");}public int f(){   //错误  返回值类型不一样 不构成方法重写return 0;}
}class A{   //A类  父类public Object f(){System.out.println("A-->f()");return null;}
}
class B extends A{   // B继承A 子类public String f(){   //名称、参数都一样 String是Object的子类  构成方法重写System.out.println("B-->f()");return null;}}
子类方法不能缩小父类方法的访问权限（可以相等或者放大）：

public -> protected ->默认 -> private
class A{   //A类  父类public Object f(){System.out.println("A-->f()");return null;}
}
class B extends A{   // B继承A 子类protected String f(){   // 错误。，因为父类为public  protected比public小System.out.println("B-->f()");return null;}}class A{   //A类  父类protected Object f(){System.out.println("A-->f()");return null;}
}
class B extends A{   // B继承A 子类public String f(){   // 正确System.out.println("B-->f()");return null;}
}

多态（多种状态）：方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

多态的特点：

1、多态的前提：继承，要有方法的重写

2、父类引用指向子类的对象，如：Animal animal= new Cat();

3、多态中，编译看左边，运行看右边

多态的具体体现：方法的多态（重写和重载就体现多态）
public class Hello{public static void main(String[] args){//方法重载体现多态A a=new A();//这里我们传入不同的参数，就会调用不同sum方法System.out.println(a.sum(10,20));System.out.println(a.sum(10,20,30));B b=new B();a.say();b.say();}
}
class B{  //父类public void say(){System.out.println("B say()...");}
}
class A extends B{  //子类public int sum(int n1,int n2){    //与下面的sum构成多态return n1+n2;}public int sum(int n1,int n2,int n3){return n1+n2+n3;}public void say(){System.out.println("A say()...");}
}
public class Hello{public static void main(String[] args) {Animal animal= new Animal();animal.cry();animal=new Dog();animal.cry();//因为运行时，这时就执行到该行是，animal运行类型是dog 所以cry就是dog//animal 编译类型Animal,运行类型就是Catanimal =new Cat();animal.cry();}
}
class Animal {public void cry(){System.out.println("Animal...");}
}
class Cat extends Animal{public void cry(){System.out.println("Cat cry()...");}
}
class Dog extends Animal{public void cry(){System.out.println("dog cry()...");}
}
向上转型：父亲的引用指向了子类的对象

语法：父类类型引用名 = new 子类类型（）；例：Animal animal = new Cat();

特点：1、编译类型看左边，运行类型看右边

2、可以调用父类中的所有成员（需遵守访问权限），不能子类中特有成员