对象可以为几个 每一个对象都有独立的属性和行为 不会相互影响
boolean 默认值为false
Person p3 = p2 和数组一致
方法中的变量都是局部变量!
属性 前面可以加权限修饰符，但是局部变量不可以，也可以理解为这前面有public例如public void eat()
比如 public private protected 缺省（意为前面什么都不加）以后会讲
类，数组，接口有默认的初始值，但是局部变量却没有（想象它比较地低级）
输出显示错误（类中行为地变量也是局部变量）
根据这张图可以知道属性都在堆里面
类中地行为就是方法（函数）
Arrays.sort()排序
行为里面也可以调用属性（想象c语言）
.？ ？为方法（行为）
方法里面地内容为方法体
当行为为private为权限修饰符则无法在main方法中进行调用
类不管写在main前面还是后面都一样（c语言）
break结束循环，return结束方法
方法（行为）中可以调用方法或者属性
且都不用加前缀，因为本来就在里面
public的class在使用调用方法时（或者其它时）必须有
public static void main(Stringp[] args)不然会被报错说是语法错误，在。。之后应该为identifier
Math.PI 为Π
调用方法时不要忘了（）例如.eat()
test.method 是先打印后再赋值给d的
必须说明具体是number 还是什么
package com.atguigu.contact;
import java.lang.reflect.Array;
class Student//相当于创造了一种数据类型 { int number; int state; int score; } class Test { public static void main(String[] args) { // int[] array=new int[20]; // for (int i = 0;i<20;i++) // { // Student array[i] = new Student(); // } 错误的 Student[] array = new Student[20];//正确的理解为 Student[] 为int[] 的相似类型 Student型的数组
for (int i = 0;i<20;i++)
{
array[i]= new Student();//上面new的只是Studnet[]型的数组这里是new对象 这里不加Student因为本来就是
array[i].number=i+1;//★
array[i].score=(int) (Math.random()*101);//因为其为double
} for (int i = 0;i<20;i++)//加年级为3的信息输出 { if (array[i].state==3) System.out.println(array[i].number +"" + array[i].state+""+array[i].score); }
for (int i =0;i<19;i++)//冒泡排序排成绩 { for (int j = i+1;j<array.length;j++) { if (array[i].score>array[j].score) { int temp = array[i].score; array[i].score=array[j].score; array[j].score = temp;
}
}
}
for (int i = 0;i<20;i++)
{
System.out.println(array[i].score);
}
}
}
for (int i =0;i<19;i++) { for (int j = i+1;j<array.length;j++) { if (array[i].score>array[j].score) { Student temp = array[i];//★ array[i]=array[j]; array[j] = temp;
}
这里是一起交换，不是直交换成绩
main方法里面既可以调用其它类的属性，行为也可以调用本类中的行为即出了main方法之后再public void..()但是此时没有出类，也相当于类中的行为调用出现这种情况的原因是进行将大段代码封装后比较好看
在public static void main()
和public void eat() 之中两者只差了static但是后者可以直接调用本类中的方法但是main却要先 new 才能调用
public void test(int[] a)为声明时
但调用时为 先new再 .test(a);
这里的Student[]时一个类型和int一样，所以不能乱改为Teacher之类的
改进后：
package com.atguigu.contact;
import java.lang.reflect.Array;
class Student//相当于创造了一种数据类型 { int number; int state; int score; } class Test { public static void main(String[] args) { // int[] array=new int[20]; // for (int i = 0;i<20;i++) // { // Student array[i] = new Student(); // } 错误的 Student[] array = new Student[20];//正确的理解为 Student[] 为int[] 的相似类型 Student型的数组
for (int i = 0;i<20;i++)
{
array[i]= new Student();//上面new的只是Studnet[]型的数组这里是new对象 这里不加Student因为本来就是
array[i].number=i+1;//★
array[i].score=(int) (Math.random()*101);//因为其为double
} // for (int i = 0;i<20;i++) // { // if (array[i].state==3) // System.out.println(array[i].number +"" + array[i].state+""+array[i].score); // } Test t = new Test(); t.sort(array); t.printf(array); // for (int i =0;i<19;i++) // { // for (int j = i+1;j<array.length;j++) // { // if (array[i].score>array[j].score) // { // Student temp = array[i];//★ // array[i]=array[j]; // array[j] = temp; // // }
//}
//}
for (int i = 0;i<20;i++)
{
System.out.println(array[i].number+" "+array[i].state+" "+array[i].score);
}
}
public void sort(Student[] array)
{
for (int i =0;i<19;i++)
{
for (int j = i+1;j<array.length;j++)
{
if (array[i].score>array[j].score)
{
Student temp = array[i];//★
array[i]=array[j];
array[j] = temp;
}
}
}
}
public void printf(Student[] array)
{
for (int i = 0;i<20;i++)
{
if (array[i].state==0)
System.out.println(array[i].number +"" + array[i].state+""+array[i].score);
}
}
}
类与对象的关系：比如说调用Scanner类里面的.nextInt()
就必须要创建对象（对象都有独立的属性和行为）
行为结束局部变量被回收，main结束后 堆中new的数据被回收
JVM将编译生成的class文件传入内存进行解析 （放在栈和堆中）
局部变量不能用权限修饰符
""万事万物皆对象""在java中有对象，html 数据库 与java交互时，其结构数据都会转换为类和对象
Student[] test 中的Student是类为引用类型
出现这个的原因是因为我们要用很多个对象所以创建个这样的数组
下面才进行创造对象的操作（先想创造数组，再想创造对象）
String是个类（想c语言中的数组和字符串）
注意一二句
package com.atguigu.contact;
import java.lang.reflect.Array; class Phone { double price; public void feiyong() { System.out.println("这台手机的费用为："+price); } } class Test { public static void main(String[] args) { new Phone().price = 16.9;//但是打印结果还是0.0 new Phone().feiyong();
}
}
这个还是很好理解的相当于每次都是重新new了一个对象出来
class Phone { double price; public void feiyong() { System.out.println("这台手机的费用为："+price); } } class PhoneMall { public void fee(Phone phone)//再次说明了类也是数据类型 { phone.feiyong(); } }
class PhoneMall { public void fee(Phone phone) { phone.feiyong(); } } class Test { public static void main(String[] args) { new Phone().price = 16.9; new Phone().feiyong(); new PhoneMall().fee(new Phone());//这里是匿名对象的使用
}
}
if (flag)
{
break; 这里flag表示如果。。。。成立就立即停止为boolean类型
}
写查找时：
if (array[i]==dest(destination))
{
return i;
}else
{
return -1;
}
方法的重载
例如 sort(byte[] a) 和sort(double[] a)两个方法的参数不同（个数或者类型） 所以可以
sort(int a, int b) sort(int b, int a)两个不同可以且跟sort前面的东西都无关只看sort之后
这个认识一下就行了，定义方法时注意一下
比较三个数字大小时用三元
可变个数形参（0-无限）
package com.atguigu.contact;
public class Study { public static void main(String[] args) { KeBian k = new KeBian(); k.canShu(1); }
} class KeBian { public void canShu(int ... i)//★可以理解为int[] i 即可以 i.length { System.out.println("hello");
}
}
但是这个可变个数形参必须在后面应该为(int i ,String ... str )且只有一个可变个数形参
创建对象还不熟悉 想象?.! ?应该为。。。类型的
package com.atguigu.contact;
public class Study { public static void main(String[] args) { int m=1 , n=2; Study test = new Study(); test.jiaoHuan(m,n);//这里mn没有交换，因为main中的mn和调用函数的mn不同，上面的mn转换为值1，2后分别付给了 //下面调用函数的m和n 而且如果时同个m n 就会报错但是没有，而且 jiaoHuan这个方法做完后 m n被回收了 System.out.println(m+" "+n);
}
public void jiaoHuan(int m, int n)
{
int temp = m;
m = n;
n= temp;
}
}
所以将（）中的类型为基本数据类型应该为引用数据类型例如下图
package com.atguigu.contact;
public class Study {
public static void main(String[] args)
{
JiaoHuan swap = new JiaoHuan();
Data data = new Data();
swap.jiaoHuan(data);
System.out.println(data.i+" "+data.m);
}
}
class Data { int i=10; int m=20; } class JiaoHuan { public void jiaoHuan(Data data) {
int temp = data.i;
data.i=data.m;
data.m = temp;
}
}
想象必须要用引用类型所以一定是?.？
所以先写int temp = data.i; data.i=data.m; data.m = temp; 然后再写上面的public 写时想到Data data 所以才去构造class Data
最后在main中一起调用
当然这样太麻烦了可以直接
创建对象时把方法加载到了方法区
System.exit(0)可以强行不执行后面的语句
package com.atguigu.contact;
class Study { public static void main(String[] args) { PassObject test = new PassObject(); Circle c = new Circle(); test.printAreas(c,5);
}
} class Circle { double radius; public double findArea() { return Math.PIradiusradius; } } class PassObject { public void printAreas(Circle c,int time)//这里Circle c 调用这里要注意 { for (int i=0;i<time;i++) { c.radius=(double)i;
double s =c.findArea();
System.out.println(c.radius+" "+s);
}
}
}
package com.atguigu.contact;
class Study {
public static void main(String[] args)
{
Test test = new Test(); int m =test.getSum(2); System.out.println(m);
}
} class Test {//递归先从外到里 （else中）再从里到外 if 到else最后return
public int getSum(int n)
{
if (n==1)
{
return 1;
}
else
{
return n+getSum(n-1);
}
}
}
递归一般都是return +本身函数 和return +一个具体数字 （好让循环从里面向外面流出）
虽然引用数据类型是传递地址值但是String s1 ="hello"是在字符串常量区不在堆中，而且hello 是由char[]组成的其大小不能改变所以只能创造新的，导致不能一起改变
把该暴露的暴露，该隐藏的隐藏：封装性
class Study1 { int age=2; public void printf() { System.out.println(age); } }
类中的属性 方法中是可以使用的
属性赋值时若为-但是又要正的，就要设置一个方法判断为正才 赋给这个属性，也可以在属性哪里加private让整个main无法调用，只能用上面设定的方法进行操作
加个private就是封装性（隐藏性）
封装性（想封印）的体现（不止这一个）：先private之后也要提供公共的方法来设置和获取这个属性
还可以对类中的方法private让其只有在其它本类方法中使用
java的四种权限修饰符从小到大 private 缺省 protected public(类中结构可以)
注意类只能缺省或者public
缺省的不同包不能用
package com.atguigu.contact; class Person { private int age; public void setAge(int i) { if (i>=0&&i<=130) { age=i; }else {
}
}
public int getAge()
{
return age;
}
} class Study { public static void main(String[] args) { Person test = new Person(); test.setAge(5); int m = test.getAge(); System.out.println(m);//这里可以直接输入 test.getAge()，因为m=它 } }
任何一个类都有构造器（constructor） field:属性
Person test = new Person(); 这是new+构造器 在new的过程中会实行下面Person（）内的内容，如果不写下面的public Person（）则会默认为一个 public Person()
{
}
class Person
{
public Person()
{
System.out.println("hello");
}
}
方法时功能的构建但是构造器时构建对象来调用方法
固定格式 权限修饰符+类名（形参列表）{}
其实与方法的格式只有一个不同那就是返回值 可以想象构造器不需要返回值
package com.atguigu.contact; class Person { int age=1; public Person() { System.out.println("hello"); } public Person(int i)//★这个也叫重载 { age = i; }
public void setAge(int i)
{
if (i>=0&&i<=130)
{
age=i;
}else
{
}
}
public int getAge()
{
return age;
}
} class Study { public static void main(String[] args) { Person test = new Person(); Person test2 = new Person(3);//★ System.out.println(test2.age);
}
}
可以在类中定义多个构造器只要形参不同
作用 1创造对象 2初始化对象的
如果一旦提供了构造器 例如 public Person(int i ){} 那么就无默认的public Person(){} 这个时候使用new Person() 会报错，需要自己创建public Person(){};
先写属性再写构造器再写方法 属性的赋值方法也是这样的顺序
this：
public void set(int base,int height)
{
base =base;
height =height;//这样系统报错 不能区分 局部变量和成员变量，都认为是局部变量
}
public class Person { public static void main(String[] args) { int[] array = new int[]{1,2,3}; for (int i:array)//：想象从 i 到 数组 即 i为从数组里面拿的数字 { System.out.println(i);
}
}
}
this在调用本类中属性和方法时可以不加，但是一旦重名必须加 ★ 注意this的含义，跟着感觉走
public void eat() { this.change(age); } public PersonTest(int age)//构造器也是一样的 { this.age = age;
eat();//构造器里面可以调用当前正在创建对象的方法
}
public PersonTest(int age)
{
this.age = age;
eat();
}
public PersonTest()
{
this(3);//这是调用上面的构造器 防止冗余即相同的部分出现 可以这么想本来是
//这下面为自己的函数 两者不能颠倒
// this.eat() 现在没有了 . 那就没有了eat
}
}
一个构造器不能调用两个 因为其中一个不在首行
package com.atguigu.contact;
class Boy { private String name; private int age; public void set(String name,int age) { this.name = name; this.age=age; } public String getName() { return name; } public int getAge() { return age; } public void marry(Girl girl)//★这里不够熟悉 { girl.setName("Jerry"); name = "Tom"; System.out.println(name + "和"+girl.getName()+"相爱了"); } public void shout() { if (age>22) { System.out.println("你们可以结婚了"); }else { System.out.println("年龄不够"); } }
}
class Girl
{
String name;
int age;
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 void marry(Boy boy)
{
boy.marry(new Girl());//这里也可以直接this 不用新造对象 在方法里面也可以new 不管是不是main方法
}
}
class Person
{
public static void main(String[] args)
{
Boy boy = new Boy();
Girl girl = new Girl();
girl.marry(boy);
}
}
// 在1至2019中，有多少个数的数位中包含数字9？ //注意，有的数中的数位中包含多个9，这个数只算一次。 //例如，1999这个数包含数字9，在计算只是算一个数。
public class Main { public static boolean getResult(int num) {//这里我没有构造方法 boolean sum = false; String s = String.valueOf(num) ;//★相似的而还有 想象将什么值转换为.前面那个类型 for(int i=0; i<s.length(); i++) { if(s.charAt(i) == '9') {//这同样也是把str中的字母取出来的方法 .charAt()； sum = true ; i = s.length() ; break ; } } return sum ; } public static void main(String[] args) { int sum = 0 ; for(int i=1; i<=2019; i++) { if(getResult(i)) { sum ++ ; } } System.out.println(sum); ———————————————— 版权声明：本文为CSDN博主「nuist__NJUPT」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：blog.csdn.net/nuist_NJUPT… //里面有思路可以借鉴
String.valueOf()（与charAt()一起用方便比较数字每个位）; Integer.parseInt();
class Study { public static void main(String[] args) { String str = "fdsklfdsjf"; char[] ch=str.toCharArray();//转换为char型数组 它是String类的不是Arrays类 Arrays.sort(ch);//这个只有记住，它和Scanner调用不同
for(char c:ch)
{
System.out.println(c);
}
}
}
b（字节） kb mb 1024的乘
C语言中strlen与java的length（）相似都没有+1但是sizeof+1了因为算的是空间
scan.next()是接受字符串
- 问题描述
给定一个单词，请使用凯撒密码将这个单词加密。
凯撒密码是一种替换加密的技术，单词中的所有字母都在字母表上向后偏移3位后被替换成密文。
即a变为d，b变为e，...，w变为z，x变为a，y变为b，z变为c。
例如，lanqiao会变成odqtldr。
输入格式
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式
输出一行，表示加密后的密文。
样例输入
lanqiao
样例输出
odqtldr
评测用例规模与约定
对于所有评测用例，单词中的字母个数不超过100。
*/
import java.util.Scanner ;
public class Main {
public static void Print(String s) {
for(int i=0; i<s.length(); i++) {
switch(s.charAt(i)) {
case 'x' : System.out.print('a'); break ;
case 'y' : System.out.print('b'); break ;
case 'z' : System.out.print('c'); break ;
}
if(s.charAt(i) != 'x' & s.charAt(i) != 'y' & s.charAt(i) != 'z' & Character.isLetter(s.charAt(i))) {
char result = (char) (s.charAt(i) + 3);//这里的转换为char很重要因为默认输出为int
System.out.print(result);
}
}
}
public static void main(String[] args) {
Scanner input = new Scanner (System.in) ;
String s = input.next();
Print(s);
}
}
————————————————
版权声明：本文为CSDN博主「nuist__NJUPT」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：blog.csdn.net/nuist_NJUPT…
- &&时判断第一个条件为false，后面的100/0==0这个条件就没有进行判断。 &时要对所有的条件进行判断，所以会对后面的条件进行判断，所以会报错。
- |也是这样的两个条件都会看
System.out.println(Math.min(3, Math.max(5,6)));有直接比较大小的方法
length不是方法，是属性，数组的属性；
public static void main(String[] args) {
int[] intArray = {1,2,3};
System.out.println("这个数组的长度为：" + intArray.length);
**length()是字符串String的一个方法；**想象 数组是字符串老大所以是属性
- public static void main(String[] args) {
- String str = "HelloWorld";
- System.out.println("这个字符串的长度为：" + str.length());
- }
int[][] arr = new int[3][2】;
System.out.println(arr[0].length);结果未2
/*
package com.atguigu.contact; import java.util.Scanner; class Study { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入回型数大小数值："); int n = scanner.nextInt(); int m = scanner.nextInt(); int[][] arr = new int[n][m];
int count = 0;//要显是的数量
int maxX = m - 1;//x轴的最大下标
int maxY = n - 1;//y轴的最大下标
int minX = 0;//x轴的最小下标
int minY = 0;//y轴的最小下表
while(minX <= maxX){//这里可以举2*2
for(int x = minX; x <= maxX; x++){
arr[minY][x] = ++ count;//第一排
}
minY ++;
for(int y = minY; y <= maxY; y++){
arr[y][maxX] = ++ count;//第二排的最后一个开始往下
}
maxX --;
for(int x = maxX; x >= minX; x--){
arr[maxY][x] = ++ count;//最后一排倒数第二个开始往左
}
maxY --;
for(int y = maxY; y >= minY; y--){
arr[y][minX] = ++ count;//为什么这里不会把第一个覆盖呢？？ 因为上面第一个++了
}
minX ++;
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
/*
- 问题描述 2015年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。 这一次，小明要帮助 n 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。 现在，这 n 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。 小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为 (x_1, y_1) 高度为 h_1 的村庄与坐标为 (x_2, y_2) 高度为 h_2 的村庄之间连接的费用为 sqrt((x_1-x_2)(x_1-x_2)+(y_1-y_2)(y_1-y_2))+(h_1-h_2)*(h_1-h_2)。 在上式中 sqrt 表示取括号内的平方根。请注意括号的位置，高度的计算方式与横纵坐标的计算方式不同。 由于经费有限，请帮助小明计算他至少要花费多少费用才能使这 n 个村庄都通电。 输入格式 输入的第一行包含一个整数 n ，表示村庄的数量。 接下来 n 行，每个三个整数 x, y, h，分别表示一个村庄的横、纵坐标和高度，其中第一个村庄可以建立发电站。 输出格式 输出一行，包含一个实数，四舍五入保留 2 位小数，表示答案。 样例输入 4 1 1 3 9 9 7 8 8 6 4 5 4 样例输出 17.41 */
import java.util.Arrays; import java.util.Scanner; public class Main { static class Node { int x; int y; int h; } public static void main(String[] args) { //输入 Node[] nodes = new Node[1002];
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
nodes[i]=new Node();//★，当时没想到
nodes[i].x = sc.nextInt();
nodes[i].y = sc.nextInt();
nodes[i].h = sc.nextInt();
}
//后面不会就没复制了
}
———————————————— 版权声明：本文为CSDN博主「nuist__NJUPT」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：blog.csdn.net/nuist_NJUPT…
System.out.println(Integer.toBinaryString(2019));
计算一个数字的约数 1-Math.sqrt(num)即可 可以举例子例如 81 100
其中，无向图的边是没方向的，即两个相连的顶点可以互相抵达。
而有向图的边是有方向的，即两个相连的顶点，根据边的方向，只能由一个顶点通向另一个顶点
