java第二天：Eclipse使用、数组、面向对象

代码界小菜鸟

已于 2022-09-07 16:12:12 修改

阅读量525

点赞数

分类专栏： java 文章标签： java

于 2022-09-05 19:54:48 首次发布

本文链接：https://blog.csdn.net/m0_61927991/article/details/126668977

版权

java 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

一、一维数组的使用

		int[] ids;//声明
//		静态初始化
		ids = new int[] {1001,1002,1003};
//		动态初始化
		String[] names = new String[5];

（1）栈（stack）：局部变量堆（heep）new出来的结构：对象、数组

二、多维数组（二维数组使用居多）

//		静态初始化
		int[][] arr1 = new int[][] {{1001,1002,1003},{4,5},{6,7}};
//		动态初始化
		String[][] arr2 = new String[5][8];

三、面向对象

1）对象的基本知识

1.java类及其类的成员：属性、方法、构造器；代码块、内部类

2.面向对象的三大特征：封装性、继承性、多态性

3.其他关键字：this、super、static、final、package

4、类：人对象：马云

5、属性：成员变量方法：成员方法

6、创建类的对象 = 类的实例化 = 实例化类

public class code1 {

	public static void main(String[] args) {
		//创建Person的对象
		Person p1 = new Person();
		
		//调用对象的结构：属性、方法
		//调用属性“对象.属性”
		p1.name="Tom";
		p1.isMale=true;
		System.out.println(p1.name);
		
		//调用方法：“对象.方法”
		p1.sleep();
		p1.talk("chinese");
	}

}

class Person{
	
	//属性
	String name;
	int age = 1;
	boolean isMale;
	
	//方法
	public void eat() {
		System.out.println("人可以吃饭");
	}
	
	public void sleep() {
		System.out.println("人可以睡觉");
	}
	
	public void talk(String language) {
		System.out.println("人可以说话，使用的是"+language);
	}
}

2）类中的属性的使用属性(成员变量) vs 局部变量

相同点：定义变量的格式相同 int a = 10; 先声明，后使用；都有其对应的作用域；

不同点：属性：可以声明属性时，指明其属性，使用权限修饰符。public prtected private 缺省，属性有默认值 int:0 String:null

class Person{

	//属性(成员变量)
	String name;
	int age = 1;
	boolean isMale;
	
	public void eat() {
		String food = "烙饼"; //局部变量
		System.out.println("人可以吃饭"+food);
	}
	
	public void talk(String language) {//language：形参，也是局部变量
		System.out.println("人可以说话，使用的是"+language);
	}
}

3）方法的举例与声明的格式

public void eat(){} 返回一个空值 public void sleep(String name){} 返回一个空值

public String getName(){} 返回一个String的值 public String getName(String name){} 返回一个String的值

返回值return 无返回 void 形参 (String name,int age)

在类的方法内部可以其他或自己调用方法

public void eat() {
	String food = "烙饼"; //局部变量
	System.out.println("人可以吃饭"+food);
}
	
public void talk(String language) {//language：形参，也是局部变量
    System.out.println("人可以说话，使用的是"+language);
	eat();
}

4）方法的重载

1.定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数类型不同即可

class OverLoadTest{
	public void getSum(int i,int j) {
		
	}
	
    public void getSum(String i,int j) {
		
	}
}

5）可变形参

  public void getSum(String ...strings ) {
     for(int i = 0;i<strings.length;i++){
        sys(strings[i]);
     }
  }

可变形参要放在末尾 public void test(int n,String ...strings){}

6）封装性与隐藏

（1）我们需要验证属性，并且用户不能使用实例.属性修改数据，只能通过方法修改

public class code1 {

	public static void main(String[] args) {
		Person zhangsan = new Person();
		//zhangsan.age=10; 报错private不能直接修改
		zhangsan.setAges(10);
		zhangsan.show();
	}
}

class Person{
	String name;
	private int age;
	
	public void setAges(int a) {
		age = a;
	}
	
	public void getAges() {
		System.out.println(age);
	}
}

7、封装性的体现

我们将类的属性私有化（private）同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）次属性的值

修饰符内部类同一个包不同包的子类同一个工程

private yes

缺省(什么都不写)yes yes

protected yes yes yes

public yes yes yes yes

8、封装的练习

public class code1 {

	public static void main(String[] args) {
		Person p1 = new Person();
		//p1.age =1;编译不通过
		p1.setAge(12);
		System.out.println(p1.getAge());
	}
}

class Person{
	private int age;
	
	public void setAge(int a) {
		if(a < 0 || a > 130) {
			System.out.print("数据非法");
			return;
		}
		age = a;
	}
	
	public int getAge() {
		return age;
	}
}

9）构造器||构造方法constructor使用

一、构造器的作用：创建对象初始化对象信息

二、说明：定义构造器，一个类中一定会有一个构造器，有了构造器之后，系统就不提供空构造器了

public class code1 {

	public static void main(String[] args) {
		Person p1 = new Person(19);
		//p1.age =1;编译不通过
		p1.setAge(12);
		System.out.println(p1.getAge());
	}
}

class Person{
	private int age;
	
	//构造器
	public Person(int ages) {
		age = ages;
		System.out.println(ages);
	}
	
	public void setAge(int a) {
		if(a < 0 || a > 130) {
			System.out.println("数据非法");
			return;
		}
		age = a;
	}
	
	public int getAge() {
		return age;
	}
}

10）关键字的this使用

this可以修饰方法和属性 this指的是实例对象；在类的方法中我们可以使用“this.属性”或“this.方法”，调用当前对象的属性或方法，但是通常情况下，我们都选择省略。特殊情况下，属性名与形参名同名时使用；

在构造器下调用其他构造器 this()；构造器的调用必须放在首行一个构造里面只能调用一个其他构造器

public class code1 {

	public static void main(String[] args) {
		Person p1 = new Person(19);
		//p1.age =1;编译不通过
		p1.setAge(12);
		System.out.println(p1.getAge());
	}
}

class Person{
	private int age;
	
	//构造器
	public Person(int ages) {
		this.age = ages;
		System.out.println(this.age);
	}
	
	public Person() {
		this(18);//调用本类中指定的其他构造器
	}
	
	public void setAge(int age) {
		if(age < 0 || age > 130) {
			System.out.println("数据非法");
			return;
		}
		this.age = age;
	}
	
	public int getAge() {
		return this.age;
	}
}

11）package、import关键字

一、package关键字的使用

1.为了更好的实现项目中的管理，提供包的概念

2.声明package声明类或接口所属的包，声明在源文件就可

3.每点一次就是一层文件目录 com.atguigu.exer

二、import关键字的使用

1.import 导入导包

四、客户管理案例（还没写）

添加用户案例

五、继承性

定义：许多类的共有的方法与属性，我们就可以把他抽取成为一个父类，记得需要符合规则，不能为了继承而继承

好处：减少了代码的复杂，提高代码的质量，为多态打基础

A继承了B，A就获取了B的属性与方法

父类的属性是私有的属性，儿子也继承了，只是不能直接调用，因为封装性的原因 extends关键字

子类继承了父类，但是也可以有自己的特有的方法

子类只能继承一个父类哦

所有的父类的最终父类就是Object类

class Student extends Person{}

六、重写

子类继承父类，然后重写父类的方法进行重写，需要和父类的方法名与形参列表都要一样哦

public class HelloWorld {
    public static void main(String[] args) {
        Student student = new Student();
        student.eat();
    }
}
class Person {
    public void eat(){
        System.out.println("吃饭");
    }
}
class Student extends Person{
    public void eat(){
        System.out.println("我不想吃");
    }
}

1.重写的规定：

权限修饰符  返回值类型  方法名(形参列表){方法体}

子类叫重写的方法，父类叫做被重写的方法
子类的方法名与父类的方法名一样，形参列表也要一样
子类的权限修饰符一定不能小于父类的修饰符
子类的不能重写父类修饰符为private的方法
父类的返回类型是void和基本类型，子类的也是void，和基本类型，父类的返回值类型为A类，子类的返回类型可以是A类，也可以是A类的子类
父类声明了static修饰符我们也不能重写

七、super关键字

super关键字可以用来调用父类的：属性、方法、构造器

1.子类与父类的属性同名的时候：我么需要使用super，一般情况下是不会出现这种情况的

public class HelloWorld {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }
}
class Person {
    String name = "我是父亲";
}
class Student extends Person{
    String name = "我是儿子";
    public void show(){
        System.out.println(this.name+","+super.name);
    }
}

2.子类调用父类的方法，一般也是同名才用 super.父类方法名()

3.子类调用父类的构造器（常用） super(name,age)

关于this()调用本类的构造器，与super()调用父类的构造器只能二选一。如果我们没写this和super默认调用super的空参，记住只能写在第一行

public class HelloWorld {
    public static void main(String[] args) {
        Student student = new Student(19,"张三");
        student.eat();
    }
}
class Person {
    String name;
    public Person(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println(name);
    }
}
class Student extends Person{
    int age;
    public Student(int age,String name){
        super(name);
        this.age = age;
    }
}

八、多态性

public class HelloWorld {
    public static void main(String[] args) {
        Man man = new Man();
        man.eat();
        man.walk();
        man.earnMoney();
//        **************
        //多态性 父类的引用指向子类的对象（指向的是左边）
        Person p2 = new Man();
        Person p3 = new Woman();
        //多态的使用，当调用子类同名同参的方法时，实际执行的是子类重写父类的方法--虚拟方法调用
        p2.eat();
        p3.eat();

//        p2.earnMoney(); 没有重写父类的这个方法，所以调用不了这个方法
//        只能调用父类的方法，但是运行的时候是看左边
//        总结：编译看左边，执行看右边
//        多态性的使用前提：类的继承，方法的重写
        
    }
}
class Person {
    String name;
    int age;
    public void eat(){
        System.out.println(name);
    }
    public void walk(){
        System.out.println("人：走路");
    }
}
class Man extends Person{
    boolean isSmoking;
    public void earnMoney(){
        System.out.println("男人负责养家");
    }

    public void eat(){
        System.out.println("男人多吃肉，长肌肉");
    }

    public void walk(){
        System.out.println("男人：走路");
    }
}

class Woman extends Person{
    boolean isBeautiful;
    public void earnMoney(){
        System.out.println("女人负责貌美");
    }

    public void eat(){
        System.out.println("吃火龙果");
    }

    public void walk(){
        System.out.println("女人：走路");
    }
}

九、多态性的使用

public class HelloWorld {
    public static void main(String[] args) {
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.func(new Dog());
        helloWorld.func(new Cat());
    }

    public void func(Animal animal){
        animal.eat();
        animal.shout();
    }
}

class Animal{

    public void eat(){
        System.out.println("动物：进食");
    }

    public void shout(){
        System.out.println("动物叫");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }

    public void shout(){
        System.out.println("汪汪汪");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void shout(){
        System.out.println("喵喵");
    }
}

对象的多态性是不适用于属性的，只适用于方法（属性编译和运行都看左边）

十、向下转型

在多态中我们只能调用父类定义的方法但是我们想要调用子类的方法，所以我们要把其向下转型

Person p2 = new Man() Man m1 = (Man) p2 这样就可以调用儿子的主键，类型转化异常，男的不能转成女的

可能ClassCastException的异常

instanceof 关键字 a instanceof A:判断a是否是A的实例。如果是，返回true；如果不是则返回false

== 用于引用数据时比较的是地址值

十一、Object类的使用

clone 克隆数组等等

p= null System.gc()通知系统回收对象.getClass()获取自己所属的类

十二、==与equals区别

==：运算符用于：基本数据类型变量和引用数据变量中，基本数据比较的值；引用数据比较的是地址

char i =10; int a = 10 a==i (true) double b = 10.0; int c = 10; b==c(true)

equals:只适用于引用数据，像String，Date，File比较的不是地址，而是比较实体内容是否相等

十三、toString方法

调用实体内容返回实体信息

十四、包装类数据转化

new Integer("123") 字符串转整形整形.toString()转字符串等等

包装类调用xxxValue()得到什么类型的数据

十五、自动装箱与开箱

自动装箱：就是例如一个int定义的可以直接赋值给Integer得类里面 int a =10; Integer b = a;

基本类型转字符串==>String.valueof(123);

十六、static关键字

引入每一个中国人都有国籍为中国，所以要避免重复化该咋办呢？

1.使用static修饰属性

：叫做静态变量（类变量），属性是否使用static修饰；创建了类的多个对象，多个对象共享同一个静态变量，当其他对象修改静态变量，会导致其他对象用的时候就是变了的。

2.静态变量随着类的加载而加载。可以直接用类调用 Chinese.nation="中国"

静态变量放在方法池当中

2.使用static修饰方法

：静态方法：随着类的加载而加载，所以可以直接用类调用类名.方法名 Chinese.方法名

静态方法中只可以调用静态方法不能调用非静态方法；静态方法中不可以调用super和this关键字，静态属性前面的就不是this了而是类名 this.nation(错) Chinese.nation(对)

3.什么时候要声明static：

属性什么时候需要使用static修饰属性：这个属性可以被多个人使用，不会应为人不同而变化

方法什么时候需要加上static：操作静态属性的方法，通常设置为static的

public class HelloWorld {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.name="姚明";
        c1.age=40;

        Chinese c2 = new Chinese();
        c2.name="马龙";
        c2.age=30;
        c2.nation = "china";
        System.out.println(c1.nation);
    }
}

class Chinese{
    String name;
    int age;
    static String nation;
}

十七、单例的设计模式

就是只能创建一个对象，无论创建多少个对象，都指向一个类

1.饿汉式：线程安全（推荐写这个）

class Chinese{
    private Chinese(){
    }
    private static Chinese chinese = new Chinese();
    public static Chinese getInstance(){
        return chinese;
    }
}

2.懒汉式：线程不安全

class Chinese{
    private Chinese(){
    }
    private static Chinese chinese = null;
    public static Chinese getInstance(){
        if(chinese == null){
            chinese = new Chinese();
        }
        return chinese;
    }
}

十八、代码块

作用：用来初始化类、对象

代码块有修饰符的话只能使用static

分类：静态代码块 vs 非静态代码块

    //静态代码块
    static {
        System.out.println("类加载完我直接执行，只执行一次");
    }
    //非静态代码块
    {
        System.out.println("造完对象才执行，每创建一个我执行一次,可以对属性进行初始化");
    }

十九、final：最终的

final：修饰类、此类不能被继承了。

final：修饰方法，这个方法就不能在被重写了。

final：修饰变量：此时的变量就被成为常量，赋值以后就不能被赋值了，初始化赋值，构造器，代码块

final：修饰局部变量，常量

final+static 全局常量：记住要大写

二十、抽象类与抽象方法

abstract关键字：修饰类，方法

abstract修饰类的时候，抽象类就不能实例化了，但一定有构造器哦

abstract修饰方法的时候，只有方法的声明，没有方法体（包含抽象方法一定有抽象类）

abstrac不能修饰private

public class HelloWorld {
    public static void main(String[] args) {

    }
}

abstract class Person{
    String name;
    public abstract void eat();
}

class Student extends  Person{
    public void eat(){

    }
}

二十一、创建抽象类的子类方法

public class HelloWorld {
    public static void main(String[] args) {
        Person p = new Person(){
            
        };
    }
}

abstract class Person{
    String name;
}

二十二、接口 interface implement单继承多接口

jdk7以前：全局变量和抽象方法（static和public可以省略）

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(Flyablie.A);
    }
}

interface Flyablie{
    //全局常量
    int A = 10;
    //抽象方法
    public abstract void eat();
}

jdk8:有static与default

二十三、内部类

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(Flyablie.A);
    }
}

class Person{
    //静态内部类
    static class Dog{

    }
    //非静态内部类
    class Student{

    }
}