第三周-Java基础

2022-03-07

Student类

package day0307;
/**
 * 学生类
 * 一个基本的学生类
 * 类的语法 空的类：修饰符 class 类名{}
 * 属性的语法：修饰符 数据类型(类) 属性名;
 * 创建对象的语法：类名 自定义的对象名 = new 类名();
 * @author Katrina
 */
public class Student {

	//属性的语法：修饰符 数据类型(类) 属性名;
	public String name; //姓名
	public int age; //年龄
	public String sex; //性别
	
	public static void main(String[] args) {
		//类名 自定义的对象名（变量） new 类名(); String str = new String("");
		Student student = new Student(); //新建一个学生对象student，开辟空间存放student对象，student指向内存空间
		student.name = "李阳"; //对对象的属性进行赋值
		student.age = 18; 
		student.sex = "男";
		System.out.println("学生的名字叫" + student.name);
		System.out.println("学生的年龄是" + student.age);
		System.out.println("学生的性别是" + student.sex);
		student.eat();
		student.sleep();
		student.lesson();
	}
	
	/*
	 * 吃饭
	 */
	public void eat() {
		System.out.println("吃泡面");
	}
	
	/*
	 * 睡觉
	 */
	public void sleep() {
		System.out.println("睡10个小时");
	}
	
	/*
	 * 上课
	 */
	public void lesson() {
		System.out.println("上技术课和职场课");
	}
	
}

Teacher类

package day0307;
/**
 * 教师类
 * @author Katrina
 */
public class Teacher {

	String name;
	int age;
	String sex;
	String lesson;
	
	public static void main(String[] args) {
		//一般情况下，可以在类的方法中引用其他类创建对象。前提：被引用的类符合引用条件
//		Student student = new Student();
//		student.name = "小明";
//		System.out.println("学生的名字是" + student.name);
		
		Teacher teacher = new Teacher(); //新建一个教师对象 teacher
//		teacher.name = "孙传波";
//		System.out.println("老师的姓名是" + teacher.name);
//		teacher.age = 30;
//		System.out.println("老师的年龄是" + teacher.age);
//		teacher.sex = "男";
//		System.out.println("老师的性别是" + teacher.sex);
//		teacher.lesson = "Java";
//		System.out.println("老师授课内容是" + teacher.lesson);
//		System.out.println(teacher.name + "," + teacher.age + "," + teacher.sex + "," + teacher.lesson);
		
//		teacher.setAge(10);
		int num = 25;
		//对象.方法 通过传值，将实参num传递给对象teacher所引用的方法setAge的形参，在方法内完成对对象属性的赋值
//		teacher.setAge(num);  //对象.方法
//		System.out.println(teacher.age); //25
		System.out.println("xx" + teacher.name + "xx"); 
		teacher.Teach();
	}
	
	/*
	 * 设置年龄的方法
	 */
	public void setAge(int num) {
		age = num;
	}
	
	/*
	 * 上课的方法
	 */
	public void Teach() {
		System.out.println("教师上课");
	}
	
}

Cat类

package day0307;

public class Cat {

	String color = "黑色";
	int age = 3;
	String name = "DaMao";
	String sex = "女";
	
	public static void main(String[] args) {
		Cat cat = new Cat();
		System.out.println("小猫的名字叫" + cat.name);
		System.out.println("小猫的年龄是" + cat.age);
		System.out.println("小猫的颜色是" + cat.color); 
		System.out.println("小猫的性别是" + cat.sex);
		cat.eat();
		cat.sleep();
	}
	
	/*
	 * 吃饭
	 */
	public void eat() {
		System.out.println("吃鱼");
	}
	
	
	/*
	 * 睡觉
	 */
	public void sleep() {
		System.out.println("睡觉");
	}
	
}

2022-03-08

Student类

package day0308;

/**
 * 基本类
 * 1.属性：是这群对象抽象出来的类共有的特性、特征
 * 属性语法：修饰符 数据类型 属性名称;
 * 数据类型可以是基本数据类型（8种）、引用数据类型（String、数组、其他类）
 * 2.方法语法：修饰符 返回值类型 方法名 (参数列表) {方法体}
 * 返回值类型：无返回、基本数据类型、引用数据类型
 * 参数列表：数据类型 参数名
 * 参数可以有，也可以没有。根据方法是否需要接收一定的条件来确定
 * 3.新建对象：类名 对象名 = new 类名();
 * 规则：类名必须是经过声明的类：对象名可以自定义
 * @author Katrina
 */
public class Student {

	public String name; //属性-姓名
	public int age;
	public String sex;
	
	//无参方法
	public void study() {
		System.out.println("学生学习");
	}
	
	//有参方法
	public int older(int num) {
		System.out.println("年龄是：" + num);
		return ++num;
	}
	
	public static void main(String[] args) {
		/**
		 * 1.Student student; 栈里面开辟空间，名叫student
		 * 2.new Student(); 堆里面开辟空间，存放一个student类的对象
		 * 2.=赋值 将student指向堆里面的内存空间
		 */
		Student student = new Student(); //新建Student类的对象student
		student.age = 20; //对象属性赋值 对象.属性 （. 的）
		System.out.println("学生的年龄是：" + student.age);
		int newAge = student.older(student.age);
		System.out.println("长大一岁后是：" + newAge);
	}
	
}

Dog类

package day0308;

import java.util.Scanner;

public class Dog {

	//姓名
	String name;
	//性别
	String sex;
	//狗龄
	int age;
	
	/*
	 * 改名字
	 */
	public void changeName(String name) {
		System.out.println("改名字了，新名字叫" + name);
	}
	
	/*
	 * 吃
	 */
	public void eat() {
		System.out.println("小狗吃骨头");
	}
	
	/*
	 * 叫
	 */
	public void bark(String voice) {
		System.out.println("小狗的叫声是" + voice);
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String voice = sc.nextLine();
		Dog dog = new Dog();
//		dog.changeName("小明");
//		dog.changeName("黄晓明");
//		dog.changeName("baby");
//		dog.eat();
		dog.bark(voice);
	}
	
}

显示包列表

导包

Exercise类

package com.shaungtixi; //声明类属于那个包

//import java.util.Scanner; //导入java.util包里面的Scanner类
//import java.util.*; //通过导入所有util，来导入Scanner包
import day0308.Dog; //导包

/**
 * 导包快捷键
 * alt + / 或者 Ctrl + Shift + O
 * @author Katrina
 *
 */
public class Exercise {

	public static void main(String[] args) {
		Dog dog = new Dog();
//		Scanner scan = new Scanner(System.in); //先导包，后直接用
//		java.util.Scanner scan = new java.util.Scanner(System.in);
//		java.util.Scanner scan1 = new java.util.Scanner(System.in);
		double pi = Math.PI; //java.lang.*基础包不用导包
		System.out.println(pi); //3.141592653589793
	}
	
}

访问控制修饰符

day03081包

Teacher类

package day03081;

class Teacher {

	/*四种属性*/
	public String name; //public 公有属性，可以在任意地方使用
	protected int age; //protected 受保护的属性，跨包不能使用
	String teach; //默认修饰的属性 跨包不能使用
	private String lesson; //private私有属性，只能在本类中使用
	
	//同一个类能不能访问
	//结果->都能够正常访问到
	public static void main(String[] args) {
		Teacher teacher = new Teacher();
		teacher.name = "张三";
		teacher.age = 30;
		teacher.teach = "技术";
		teacher.lesson = "Java";
	}
	
}

Teacher2类

package day03081;

public class Teacher2 {

	/*四种属性*/
	public String name;
	protected int age;
	String teach;
	private String lesson;
	
	//同一个类能不能访问
	//结果->都能够正常访问到
	public static void main(String[] args) {
		Teacher2 teacher = new Teacher2();
		teacher.name = "张三";
		teacher.age = 30;
		teacher.teach = "技术";
		teacher.lesson = "Java";
	}
	
}

Student类

package day03081;

public class Student extends Teacher2 {

	public static void main(String[] args) {
		Teacher2 teacher = new Teacher2();
		teacher.name = "张三";
		teacher.age = 30;
		teacher.teach = "技术";
//		teacher.lesson = "Java";
		
		Student student = new Student();
		student.age = 10;
		student.name = "zhangsan";
		student.teach = "zhangsan"; //同一包内继承父类，子类可以正常访问 默认
	}
	
}

Test类

package day03081;

public class Test {

	//同一个包里面其他类，其他类里面引用原始类创建一个对象，看能否访问四种属性
	//结果->只有private无法正常访问
	public static void main(String[] args) {
		Teacher teacher = new Teacher();
		teacher.name = "张三";
		teacher.age = 30;
		teacher.teach = "技术";
//		teacher.lesson = "Java"; //报错
	}
	
}

day03082包

Student类

package day03082;

import day03081.Teacher2;

//import day03081.Teacher; //无修饰符的类，无法跨包使用

public class Student extends Teacher2 {

	public static void main(String[] args) {
//		Teacher teacher = new Teacher();
//		teacher.name = "张三";
//		teacher.age = 30;
//		teacher.teach = "技术";
//		teacher.lesson = "Java";
		Student student = new Student();
		student.age = 12;
		student.name = "zhangsan"; //不同包，子类可以正常访问
//		student.teach = "技术"; //报错，不同包，子类无法正常访问
//		student.lesson = "Java"; //报错
	}
	
}

Test类

package day03082;

import day03081.Teacher2;

public class Test {

	//不同包下，只有public可以正常访问
	public static void main(String[] args) {
		Teacher2 teacher = new Teacher2();
//		teacher.name = "张三";
//		teacher.age = 30; //报错
//		teacher.teach = "技术"; //报错
//		teacher.lesson = "Java"; //报错
	}
	
}

2022-03-09

Student类

package day0309;
/**
 * 学生类
 * @author Katrina
 */
public class Student {

	private String name;
	private int age;
	
	/* 
	 * 无返回，无参数 调用方不需要传递给方法参数，也不用接收方法返回
	 */
	public void sayHello() {
		System.out.println("你好");
	}
	
	/**
	 * 无返回，有参数 调用方需要传递给方法参数，但不用接收方法返回
	 */
	public void power(int num) {
		System.out.println(num * num);
	}
	
	/*
	 * 有返回值，无参数 调用方法不需要传递参数，但需要接收方法返回
	 */
	public String sayHello1() {
		return "你好";
	}
	
	/*
	 * 有返回，有参数 调用方需要传递参数，也需要接收方法返回
	 */
	public String getNewScore(int score) {
		if (score > 60) {
			return "及格";
		} else if (score >= 55) {
			return "还有救";
		}
		return "没救了";
	}
	
	public static void main(String[] args) {
		Student student = new Student();
		student.sayHello();
		for (int i = 1; i < 10; i++) {
			student.power(i);
		}
		System.out.println(student.sayHello1());
		String word = student.sayHello1();
		System.out.println(word);
		
		System.out.println(student.getNewScore(55));
	}
	
}

Car类

package day0309;
/**
 * 汽车类
 * @author Katrina
 */
public class Car {

	public int speed;
	public int size;
	
	/*
	 * 基本无参的构造方法
	 */
	public Car() {
		System.out.println("Car类的无参构造方法");
	}
	
	public Car(int size) {
//		int a = 1; //局部变量
//		for (int i = 1; i < 10; i++) { //局部变量
//		}
//		int i = 10; //与上面不是一个变量
		this.size = size; //形参，局部变量
		System.out.println("Car类的一个参数构造方法");
	}

	public Car(int size, int speed) {
		this.size = size;
		this.speed = speed;
		System.out.println("Car类的两个参数构造方法");
	}
	
	public static void main(String[] args) {
		Car car1 = new Car();
		Car car2 = new Car(10);
		System.out.println(car2.size);
		System.out.println(car2.speed);
		Car car3 = new Car(10, 60);
		System.out.println(car3.size);
		System.out.println(car3.speed);
	}
	
}

Dog类

package day0309;

/**
 * 类的成员，分两大类 
 * 属性（变量）和行为（方法）
 * 根据调用方式，分为静态和实例。细分为：静态变量、静态方法；实例变量、实例方法
 * 实例变量、实例方法 就是前面通俗意义上用对象进行调用的，是与对象相关的
 * 静态变量、静态方法，是与类相关的
 * @author Katrina
 */
public class Dog {

	private String name;
	private int age;
	private static int counter; //静态变量counter，初始值默认为0，整个类共享一个拷贝
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.name = "小黑";
//		dog.age = 2;
		dog.age();
//		Dog.counter = 1;
		dog.count();
		System.out.println(dog);
		Dog dog2 = new Dog();
		dog2.name = "小花";
//		dog2.age = 1;
		dog2.age();
//		Dog.counter = 2;
		dog2.count();
		System.out.println(dog2);
		
		System.out.println(Dog.counter); //2
		
		System.out.println(add(1, 2)); //调用add方法
	}
	
	/*
	 * toString()方法 输出对象的属性
	 */
	public String toString() {
		return "姓名：" + this.name + "，年龄：" + this.age + "，编号：" + this.counter;
	}
	
	public int age() {
		return age++;
	}
	
	public int count() {
		return counter++;
	}
	
	/*
	 * 静态方法 可以直接调用，不用对象名
	 */
	public static int add(int a, int b) {
		return a + b;
	}
	
}

Calculate类

package day0309;
/**
 * 计算器类
 * @author Katrina
 */
public class Calculate {

	public String brand;
	public double price;
	public static int counter;
	
	public static void main(String[] args) {
		Calculate calculate = new Calculate();
		System.out.println(calculate.abc());
	}
	
	public StringBuilder reverseStringBuilder(String song) {
		StringBuilder stringBuilder = new StringBuilder(song);
		return stringBuilder.reverse();
	}
	
	public String tan(String song) {
		brand = "deli";
		abc();
		Calculate calculate = new Calculate();
		System.out.println(calculate.abc());
		return song;
	}
	
	public int abc() {
		return 1;
	}
	
	//静态方法
	public static int add(int a, int b) {
		return a + b;
	}
	
	public static int sub(int a, int b) {
		return a - b;
	}
	
	public static int multiply(int a, int b) {
		return a * b;
	}
	
	public static int divide(int a, int b) {
		return a / b;
	}

	
	/*
	 * 方法重载1：参数类型不同
	 */
	public static int add(double a, double b) {
		return (int) (a + b);
	}
	
	/*
	 * 方法重载2：参数个数不同
	 */
	public static int add(int a, int b, int c) {
		return a + b + c;
	}
	
	/*
	 * 方法重载3：参数个数、类型都不同
	 */
	public static int add(int a, double b, double c) { 
		return (int) (a + b + c);
	}
	
}

Test类

package day0309;
/**
 * 测试类
 * @author Katrina
 */
public class Test {

	public static void main(String[] args) {
		Calculate.add(1, 2); //静态方法调用 类名.方法名() 同一个类中静态方法调用，类名可以省略
		int a = Calculate.multiply(5, 1154);
		System.out.println(a);
//		brand = "deli";
		
		Calculate cal = new Calculate();
//		cal.brand = "deli";
//		cal.price = 19.5;
		
		cal.abc();
		
		//1+2
		Calculate.add(1, 2);
		//1+1.2+2.2
		Calculate.add(1, 1.2, 2.2);
		//3+4+5
		Calculate.add(3, 4, 5);
	}
	
}

Member类

package day0309;
/**
 * 会员类
 * 构造方法：1.与类名名称一致 
 * 2.构造方法的声明没有返回值类型
 * 3.可以没有参数列表
 * 类像模板，构造方法相当于一个个具体的模板，模板有简化的，有详细的
 * 没有任何构造方法声明的时候，类会帮我们缺省创建一个基础的构造方法
 * 当我们自定义构造方法后，缺省的构造方法就没了，如果想调用，要自己创建
 * @author Katrina
 */
public class Member {

	public String name;
	public int age;
	
	/*
	 * 构造方法 public修饰，若为private，不能在其他类调用此构造方法创建对象
	 */
	public Member() {
		System.out.println("这是一个最基础的构造方法");
	}
	
	/*
	 * 含有一个String参数的构造方法
	 */
	public Member(String name) {
		this.name = name; 
		System.out.println("这是一个有一个参数的构造方法，参数是" + name);
	}
	
	/*
	 * 含有String和int两个参数的构造方法
	 */
	public Member(String name, int age) {
//		super(); //默认继承Object类 无参的构造方法
//		this(); //调用本类中无参的构造方法
		this.name = name; //this 指向当前对象的引用，相当于调用方法时完成了属性赋值
		this.age = age;
		System.out.println("这是一个有两个参数的构造方法，参数是" + name + age);
	}
	
	public static void main(String[] args) {
		/*调用Member类的构造方法创建一个member对象*/
		Member member = new Member(); 
		/*调用Member类的含有String参数的构造方法创建一个member对象*/
		Member member2 = new Member("小明");  //直接对name进行赋值
		System.out.println(member2.name);
		System.out.println(member2.age);
		/*调用Member类的含有两个参数的构造方法创建一个member对象*/
		Member member3 = new Member("小花", 18);
		System.out.println(member3.name);
		System.out.println(member3.age);
	}
	
}

A类

package day0309;

public class A {

	public A() {
		System.out.println("无参构造");
	}
	
	public A(String str1) {
		this(); //this放在构造方法里面，作为另一个构造方法的引用
		System.out.println("单参构造" + str1);
	}
	
	public A(String str1, String str2) {
		this(str1);
		System.out.println("两参构造" + str1 + " " + str2);
	}
	
	public static void main(String[] args) {
		A a = new A("111");
	}
	
}

2022-03-10

B类

package day0310;

public class B {

	private String str;
	private int age;
	
	public B() { //无参构造方法
		System.out.println("无参构造");
	}
	
	public B(String str) {
		this(); //在构造方法中，使用this()调用本类的无参构造，必须在当前方法首行
		this.str = str;
		System.out.println("单参构造 " + this.str);
//		this(); 
	}
	
	public B(String str, int age) {
		this(); //在构造方法中，使用this(单参)调用本类的单参构造
//		this.str = str; //因为this(str);已经给str赋值
		this.age = age;
		System.out.println("两参构造 " + this.str + " " + this.age);
	}
	
	public static void main(String[] args) {
//		B b1 = new B("aaa");
		B b2 = new B("aaa", 1); //一级一级的输出，输出三级
	}
	
}

Car类

package day0310;

public class Car {

	private String name = "QQ";
	private static int speed = 5;
	
	public Car() {
		this.name = "Audi";
		this.speed = 10;
	}
	
	public void hello() {
		this.name = "Benz";
		this.speed = 15;
	}
	
	public static void main(String[] args) {
		Car car = new Car(); //既是对象又是无参构造方法
		System.out.println(car); //没有toString()输出对象的内存地址，打印语句打印对象，默认调用toString()方法
		car.name = "BMW"; //对象名.实例变量
//		car.name; //要进行变量声明
		Car.speed = 2; //类名.静态变量
//		speed = 2;
		System.out.println(car);
		car.hello();
		System.out.println(car);
		int i = 0; //局部变量要进行初始化赋值，才能使用
		System.out.println(i);
	}
	
	/*
	 * toString()方法，字符串形式输出对象的属性
	 */
	public String toString() { //对象以字符串的方式输出属性
		return "车的名称：" + this.name + " 车的速度：" + speed; //this. 当前对象引用，speed静态可以直接用
	}
	
}

Dog类

package day0310;
import java.util.Arrays;
/**
 * 传引用，对象作为参数的传递，改变的是对象的属性的值，不改变引用地址
 * @author Katrina
 */
public class Dog {

	private String name;
	private int age;
	
	public void eat() {
		System.out.println("吃东西");
	}
	
	public static void sleep(Dog dog) {
		dog.age += 1;
		System.out.println("睡觉" + dog.age);
	}
	
	public void sleep() {
		this.age += 1;
	}
	
	public static int[] changeThird(int[] arr) { //引用类型默认值null
		if (arr == null || arr.length < 3) {
			return arr;
		} else {
			++arr[2];
			return arr;
		}
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog();
//		dog.sleep(dog);
//		dog.sleep(); 
//		System.out.println(dog.age);
		for (int i = 0; i < 5; i++) {
			sleep(dog);
		}
		int[] arr = {1, 3, 5, 7, 9};
//		System.out.println(changeThird(arr)); //报错，Arrays.toString()或循环遍历
		System.out.println(Arrays.toString(changeThird(arr)));
		int[] aee = arr;
		changeThird(aee);
		for (int i : aee) {
			System.out.print(i + " ");
		}
	}
	
}

Dog1类

package day0310;
/**
 * 对象数组
 * @author Katrina
 */
public class Dog1 {

	private String name;
	private int age;
	
	public int grow() {
		return ++this.age;
	}
	
	public static void main(String[] args) {
		Dog1[] dogs1 = new Dog1[2]; //创建Dog类的对象数组
		dogs1[0] = new Dog1(); //对数组的对象进行分配空间，创建具体的对象，否则会报空指针异常
		dogs1[0].age = 1; //利用数组[下标] 指向某个具体的对象
		dogs1[0].name = "laohei";
		dogs1[1] = new Dog1();
		dogs1[1].age = 2;
		dogs1[1].name = "bake";
		for (Dog1 dog1 : dogs1) {
			System.out.println(dog1.age);
			dog1.grow();
			System.out.println("长大后的年龄：" + dog1.age);
		}
//		Dog1[] dogs2 = {new Dog1(), new Dog1()};
		int[] arr = {1, 2, 3};
	}
	
}