shangxuetang057---

最新推荐文章于 2024-09-15 09:47:04 发布

我叫山鸡996

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量112

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_42938698/article/details/120845864

版权

对面向对象的理解不够深刻
这个东西不容易量化，有一个起码的标准是，能够教给别人这个东西。
不要拔苗助长，动心忍性。

57、递归算法

条件判断

循环结构

58、塞子游戏

public class TestIf01 {
	public static void main(String[] arg){
		//double d=Math.random();  //生成一个0-1随机数
		//int a=(int)(Math.random()*6+1);
		//System.out.println(d);
		int i=(int)(Math.random()*6+1);
		int j=(int)(Math.random()*6+1);
		int k=(int)(Math.random()*6+1);
		int count=i+j+k;
		if(count>15){
			System.out.println("天气不错");
		}
		if(count>=10&&count<=15){
			System.out.println("手气一般");
		}
		if(count<10){
			System.out.println("手气差");
		}
		System.out.println("得了:"+count+"分");
	}
}

59、ifelse双选择

public class TestIf02 {
	public static void main(String[] args) {
		double r= Math.random()*4;
		double area=Math.PI*r*r;
		double circle=2* Math.PI*r;

		System.out.println("周长是"+circle);
		System.out.println("面积是"+area);
		if(area>circle){
			System.out.println("面积大于等于周长");
		}else{
			System.out.println("面积小于周长");
		}
	}
}

60、ifelseif else

public class Test5 {
	public static void main(String[] args) {
		int age=(int)(100* Math.random());
		System.out.println("年龄是"+age+",属于");
		if(age<15){
			System.out.println("儿童");
		}
		else if(age<25){
			System.out.println("青年");
		}
		else{
			System.out.println("其他人");
		}
	}
}

61、Switch

public static void main(String[] args) {
		int grade=1;
		switch(grade){
			case 1:
				System.out.println("大一");
				break;
			case 2:
				System.out.println("大二");
				break;
			case 3:
				System.out.println("大三");
				break;
			default:
				System.out.println("dasi");
				break;
		}
	}

62、dowhile

public class TestWhile {
	public static void main(String[] args) {
		System.out.println("1-100求和");
		int i=1;
		int sum=0;
		while(i<=100){
			sum+=i;
			i++;
		}
		System.out.println("和为"+sum);

		int j=0;
		int sum2=0;
		do{
			sum2+=j;
			j++;
		}while(j<=100);
		System.out.println(sum2);
	}
}

64、嵌套循环

打印乘法表

public class TestDouble {
	public static void main(String[] args) {
		int i=1;
		int j=1;
		int d=0;//乘积
		for(i=1;i<10;i++){
			for(j=1;j<=i;j++){
				d=i*j;
				System.out.print(j+"*"+i+"="+d+"\t");
			}
			System.out.println("\n");
		}
	}
}

65、break和continue

产生100内随机数，直到88停止循环
我的思路

public static void main(String[] args) {
		int i;
		do{
			i= (int)(Math.random()*100);
			System.out.println(i);
		}while (i!=88);
	}

教程

public class TestContinue {
	public static void main(String[] args) {
		int i;
		while(true){
			i=(int)(Math.random()*100);
			System.out.println(i);
			if(i!=88)
			continue;
			else
				break;
		}
	}
}

打印101-150内所有质数

public class TestSushu {
	public static void main(String[] args) {
		int i;

		for(i=100;i<151;i++){
			boolean flag=true;
			for(int j=2;j<i;j++){
				if(i%j==0){
					flag=false;
				}
			}
			if(flag==true){
				System.out.println(i+"is prime");
			}
		}
	}
}

66、年薪计算器

public class TestYearSalary {
	public static void main(String[] args) {
		System.out.println("请输入月薪");
		//需要获取键盘输入
		Scanner scanner=new Scanner(System.in);
		int monthSalary=scanner.nextInt();
		System.out.println("多少个月薪");
		int monthCount=scanner.nextInt();
		int yearSalary=monthSalary*monthCount;
		System.out.println("年薪是"+yearSalary);
		if(yearSalary<700000){
			System.out.println("您的年薪为"+yearSalary+",垃圾");
		}
		else{
			System.out.println("年薪"+yearSalary+"大佬啊");
		}
	}
}

67、税收计算器

功能

public class TestTax {
	public static void main(String[] args) {
		System.out.println("请输入月薪");
		double tax;
		Scanner scanner=new Scanner(System.in);
		double before=scanner.nextInt();
		if(before<3000){
			tax=before*0.03;
			System.out.println("缴纳"+tax);
		}
		else if(before>3000&&before<12000){
			tax=0.03*3000+(before-3000)*0.1;
			System.out.println("缴纳"+tax);
		}
		else{
			tax=0.03*3000+9000*0.1+(before-12000)*0.15;
			System.out.println("缴纳"+tax);
		}
	}
}

68、方法核心详解

有三个概念
为了反复调用某个语句块
方法从属于类和对象
定义
修饰符返回值方法名形参列表
方法体
调用
对象名.方法名（实参列表）

public class TestMethod {
	public static void Love(int num){//形式参数
		System.out.println("a");
		System.out.println("a");
		System.out.println("b");
		System.out.println("b"+num);
	}
	public static int add(int a,int b,int c){
		int sum=a+b+c;
		return sum;
	}
	public static void main(String[] args) {
		Love(7);//实际参数
		int sum=add(2,3,4);
		System.out.println(sum);
	}
}

后面写一下迟到罚款方法并调用

public class TestLate {
	public static void Late(String name,double monthSalary,double lateMinute){
		if(lateMinute>1&&lateMinute<=10){
			System.out.println(name+"警告");
		}
		else if(lateMinute>10&&lateMinute<=20){
			System.out.println(name+"罚款100元");
		}
		else if(lateMinute>20&&lateMinute<=30){
			System.out.println("罚款200");
		}
		else if(lateMinute>30&&lateMinute<=60){
			System.out.println(name+"罚款"+monthSalary/30/2);
		}
		else{
			System.out.println(name+"按矿工处理，罚款"+monthSalary/30*3);
		}
	}
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("迟到时间");
		double lateMinutes = scanner.nextInt();
		System.out.println("请输入月薪");
		double monthSalary=scanner.nextInt();
		System.out.println("迟到人");
		String name=scanner.nextLine();
		Late(name,monthSalary,lateMinutes);
	}
}

69、方法重载

一个类中，可以定义多个方法名相同，但参数不同的方法。
调用时会根据不同的参数自动匹配对应的方法。
实际上是完全不同的方法，只是名称相同而已。
形参列表不同，方法不同。
主要是为了方便别人调用
形参类型、个数、顺序三者都可以引起

70、递归结构详解

递归特例
使用递归求n！

public class TestJiecheng {

	public static void main(String[] args) {
		long result=factoria(6);
		System.out.println("6的阶乘结果是"+result);
	}

	//求阶乘方法
	static long factoria(int n){
		if(n==1){
			return 1;
		}else{
			return n*factoria(n-1);
		}
	}
}

071 面向对象如何学习

类和对象
内存底层
面向对象三大特征

072 神速理解面向对象24

表格思维就是一种面向对象思维
类对应表格结构 field 字段
一行数据对应一行对象
动态方法
静态属性
有了类作为模板，就可以新建对象
表格只能存储固定数据，对象可以新增方法。

作业

public static void main(String[] args) {
		ReadInTheMorning();
	}
	private String stuNum;
	private String name;
	private String sex;
	private int age;
	private int grade;
	private String dorm;
	public static void ReadInTheMorning(){
		System.out.println("每天8：30-9：00，英语晨读");
	}

73、面向过程和面向对象12

面向过程适合简单、不需要协作的事务，重点关注如何执行。
面向对象微观上是面向过程。

74、面向对象设计者思维

通过实物，抽象出类，再设计对象。

75、类的定义、属性、方法29

真物体———雇员类——程序中的对象——真物体
总结的过程就是抽象的过程
类中属性方法构造器
属性定义该类或类的对象包含的数据或者静态特征。
也叫成员变量，需要初始化。
方法：类的行为特征和功能实现。
方法从属于类和对象
[修饰符] 方法返回值类型方法名(形参列表){
//语句
}

public class SxtStu {
	//属性
	int id;
	String sname;
	int age;
	//方法
	void study(){
		System.out.println("正在学习");
	}
	//构造器
	SxtStu(){
	}
	public static void main(String[] args) {
		SxtStu s1=new SxtStu();
		s1.id=007;
		System.out.println(s1.sname);
		System.out.println(s1.id);
	}
}

属性（成员变量），放在对象里。
方法：类的行为特征，
构造器：一个特殊的方法

main形式上属于类

系统默认初始化

76、内存分析12

地址
变量地址，操作内存块

77、内存分析22

构造器：对象的初始化
4个要点：
通过new调用
有返回值，但是不能定义返回值类型，不能再构造器使用return某个值。
自动生成无参构造器定义了就不会自动增加
构造器方法名称必须和类名一致

public class SxtStu3 {
	public static void main(String[] args) {
		Point p=new Point(3,4);
		Point origin=new Point(0,0);
		System.out.println(p.getDistance(origin));
	}
}

class Point{
	double x,y;
	public Point(double _x,double _y){
		x=_x;
		y=_y;
	}
	public double getDistance(Point p){
		return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
	}
}

78、构造方法的重载8

构造器重载

public class SggStu {
	int id;
	String name;
	int age;

	//无参构造器
	SggStu(){

	}

	SggStu(int id){
		//System.out.println(id);  //就近原则
		this.id=id;
	}

	SggStu(int id,String name,int age){
		this.id=id;
		this.name=name;
		this.age=age;
	}

	public static void main(String[] args) {
		SggStu s=new SggStu(1001,"ton",34);
		//s.id=1001;
		//s.name="gaoqi";
		//s.age=18;
	}

79、JVM内存模型26

线程下的区域：
程序计数器
java虚拟机栈方法对应一个内存空间栈帧
每次方法执行进行压栈
本地方法栈
堆：所有的对象实例，都是直接分配到堆上。
直接内存
栈是方法执行的内存模型，每个方法被调用都会创建一个栈帧
栈属于线程私有，不能实现线程间共享，栈系统自动分配，是连续内存空间。
方法区实际也是堆，只适用于存储类、常量相关的信息。

80、程序执行过程内存分析

听烦了听不下去

81、垃圾回收机制原理12

不需要反复看
大部分是堆中对象的管理
将对象赋值null,垃圾回收器负责回收所有“不可达的”对象空间

82、垃圾回收算法介绍6

引用计数法
引用可达法

83、内存管理分代机制

年轻代 minorGC
年老代 Major GCC
永久代：存放静态文件

84、容易造成内存泄漏的操作6

创建大量无用对象

85、this的本质19

“创建好的对象的地址”

创建一个对象过程：
分配对象空间
执行属性值的显式初始化
执行构造方法
返回对象的地址给相关变量
this:隐式参数
id:100
name:
构造器：初始化对象中的属性
调用另一个构造器.使用this,且必须位于第一行。
this当前对象，从属于对象。
成员变量
this不能用于static方法中。

public SggStu(int id,String name){
		//System.out.println(id);  //就近原则
		this.id=id;
		this.name=name;
	}

	public SggStu(int id,String name,int age){
		this(id,name);
		//this.id=id;
		this.name=name;
		this.age=age;
	}

86、static内存分析

静态成员变量类变量
生命周期和类相同在整个生命周期都有效

加载user 将类信息放在方法区
静态方法中不可以调用非静态方法
首先加载类信息先把图纸拿出来
静态方法不能调用
从属于对象
模具之间可以互相调用
对象可以调用模具
模具不可以调用
类是否被加载类被加载，方法就存在

对象有没有
静态方法中不能调用非静态方法。

public class User {
	int id;
	String name;
	String pwd;
	static String company="背景";
	public User(int id,String name){
		this.id=id;
		this.name=name;
	}
	public void login(){
		System.out.println("登录"+name);
	}
	public static void printCompany(){
		System.out.println(company);
		//login();
	}

	public static void main(String[] args) {
		User u=new User(101,"dd");
		User.printCompany();
		User.company="ebeo";
		User.printCompany();
	}
}

087、继承树的追溯

静态初始化块
静态属性初始化：
静态初始化块，类的初始化
四步：分配空间
默认初始化
显式初始化
调构造器，初始化所有属性

088、变量分类

局部变量：方法或语句块内部
成员变量：类内部，方法外部对象创建消失
类变量：类被加载，就有效

089、包机制

包名，域名倒着写，再加上模块名。
java.lang 包含java核心功能的类

090、import静态导入

在本类中，直接使用类名调用

091、面向对象三大特征 instanceof

代码复用，方便对事务建模。
extends 扩展
类没有多继承接口有
instanceof 左边是对象，右边是类。
当对象是右面类或子类所创建对象时，返回true.

public class Person {
	String name;
	int height;

	public void rest(){
		System.out.println("休息");
	}
}

class Student extends Person {
	int score;
	public void rest(){
		System.out.println("休息");
	}

	public void study(){
		System.out.println("学习"+this.name);
	}

public static void main(String[] args) {
		Student s=new Student("gaoqi",175,33);
		System.out.println(s instanceof Student);
		System.out.println(s instanceof Person);
	}

092、关键字方法的重写

子类重写父类的方法，
要点：
1、方法名、形参列表相同
2、返回值类型和声明异常类型，子类小于父类
3、访问权限，子类大于父类。

093、final修饰方法和类

被它修饰的变量不可改变，
修饰方法，方法不可被子类重写，但是可以被重载。
修饰类，不能被继承。

class Animal{
	public final void shout(){
		System.out.println("叫了一声");
	}
}

class Dog extends  Animal{
	public void shout(){
		System.out.println("wangwangwang");
	}
}

总结：修饰方法，不可被重写
修饰类，不能扩展，不能被继承。

094、继承和组合

组合本质：将父类对象作为子类的属性，子类通过调用这个属性来获得父类的属性和方法。

095、tostring()方法

public class Person {
	String name;
	int height;

	public void rest(){
		System.out.println("想睡觉");
	}

	public Person getFriends(){
		return new Person();
	}

	public String toString(){
		return "名字是"+name+",身高是"+height;
	}

	public static void main(String[] args) {
		Student s=new Student("gaoqi",177,"shuxue");
		s.rest();
		s.study();
		System.out.println(s.toString());
	}
}

class Student extends Person{
	String major;
	int score;

	public void study(){
		System.out.println("好好学习"+this.name);
	}

	Student (String name,int height,String major){
		this.name=name;
		this.height=height;
		this.score=score;
	}

096、equals()方法

public static void main(String[] args) {
		User u1=new User(1001,"dfs","222222");
		User u2=new User(1002,"ddd","22dd22");

		System.out.println(u1);
		System.out.println(u2);

		System.out.println(u1==u2);//判断是不是同一个对象
		System.out.println(u1.equals(u2));//判断两个对象逻辑上的值是不是一样
	}

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		User user = (User) o;
		return id == user.id;
	}

	@Override
	public int hashCode() {
		return Objects.hash(id);
	}

097、super关键字

可以通过super访问父类中被子类覆盖的方法或属性
this() 调用重载的构造器

调用父类的无参构造器方法
一个类中，若是构造方法的第一行代码没有显式调用super()，java自动调用无参构造器。

public class TestSuper01 {
	public static void main(String[] args) {
		new ChildClass().f();
	}
}

class FatherClass{
	public int value;
	public void f(){
		value=100;
		System.out.println("FatherClass.value"+value);
	}
}

class  ChildClass extends FatherClass{
	public int value;
	public void f(){
		super.f();//调用父类的普通方法
		value=200;
		System.out.println("ChildClass.value="+value);
		System.out.println(value);
		System.out.println(super.value);//调用父类的成员变量
	}
}

实例2 说明默认调用无参父类

public class testSuper02 {
	public static void main(String[] args) {
		ChildClass2 c=new ChildClass2();
		System.out.println(c);
	}
}

class FatherClass2{
	public FatherClass2(){
		System.out.println("创建父类");
	}
}

class ChildClass2 extends FatherClass2{
	public ChildClass2(){
		super();
		System.out.println("创建子类");
	}
}

super含义：直接父类对象的引用

98访问控制符

private
protected细节：
父类和子类同在一个包，子类可以访问父类的protected成员，也可访问父类对象的protected成员。
子类和父类不在同一个包，子类可以访问父类的protected成员，不能访问父类对象的protected的成员。

99、javabean get set方法

属性一般使用private访问权限
属性私有后，一般提供相应的get、set方法来访问相关属性。
对属性的赋值和读取操作
一个简单的javabean

public class Person2 {
	private String name;
	private  int age;
	private boolean flag;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		if(age<0&&age>150){
			System.out.println("年龄格式不合法");
		}else {
			this.age=age;
		}
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}

100、多态详解

同一个方法的调用，由于对象不同可能有不同的行为。
多态是方法的多态，和属性无关’
多态必要条件：继承，方法重写，父类引用指向子类对象。
父类引用指向子类对象后，用该父类引用调用子类重写的方法，多态出现。

继承重写父类引用指向子类对象
什么意思 i引用指向子类对象这个需要理解

编译父类引用指向子类对象

101、向上转型和向下转型

对象转型
向上类型转换自动
编译
运行
总结：运行起来，还是什么类型执行什么方法
强制转成任何类型，编译也可以通过，但运行不一定能。

public static void main(String[] args) {
		Dog d=new Dog();
		animalCry(d);
		animalCry(new Cat());
		//测试类型转换
		Animal a=new Dog();
		//a.seeDoor();
		Dog d2=(Dog) a;
	}

102、抽象类

定义一个抽象方法
通过abstract方法规范定义规范，要求子类必须定义具体实现
必须实现因为父类没有实现
抽象类不能实例化，不能用new来实例化
可以包含属性、方法、构造方法，只能被用来被子类调用。
只能用来继承
必须被子类实现

首先构建抽象类

public abstract class Student {
	private String name;
	abstract public void study();
	abstract public void exam();

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Student(String name) {
		this.name = name;
	}

	Student() {
	}
}

继承

class SxtStu extends Student{
	@Override
	public void study() {
		System.out.println("好好学习");
	}
	@Override
	public void exam() {
		System.out.println("考100");
	}
}

总结：定义了一些规范，给一定的自由空间。
只能被子类调用而不可以用new实例化。

103、接口的实现27

104、接口默认方法

105、接口静态方法

106、接口多继承

107、string本质 jdk源码分析

108、字符串相等判断

109、string类常用方法

110、内部类基本概念用法

不学
111、静态内部类
112、面向对象总结
113、数组三种初始化
114、内存分析初始化‘
115、数组创建和三种初始化
116、数组遍历方式
117、拷贝Array类排序
118、多维数组定义初始化15
119、object数组13
120、javabean和数组存储18
1026希望可以学完

121、Comparable接口’13
122、冒泡
跳过
123、二分查找
跳过
124、包装类基本用法 25
125、自动装箱与拆箱18

126、自定义一个包装类

127、自定义包装类完善

128、string源码分析

String
private final char value[];

129.stringbuilder和stringBuffer

130、不可变字符和可变字符使用陷阱
131、date使用方法源码分析
132、dateFormat时间格式
133、Calendar日历类的使用
134、Math类和Random类的使用
135、File类的用法
136、switch复习
137、递归结构详解
138、file类递归
139、异常机制
140、checkException
141、try_catch_finally
142、声明式异常处理
143、try_with_result
144、自定义异常4
145、百度搜索异常处理
146、idea可视化调试
147、项目开发基本说明
148、-150