package com.bjpowernode.demo01.exercise;
import java.util.Scanner;
/*
* 定义一个方法，根据成绩，返回对应的等级
*/
public class Demo01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个成绩");
int grade = sc.nextInt();
System.out.println("成绩对应的等级为" + getGrade(grade));
}
public static String getGrade(int score) {
//可以对参数接收的数据进行验证
if ( score < 0 || score > 100 ) {
//抛出一个异常
System.out.println("成绩不合理");
return "";
}
switch ( score/10 ) {
case 10:
case 9:
return "A";
case 8:
return "B";
case 7:
return "C";
case 6:
return "D";
default:
return "E";
}
}
}
package com.bjpowernode.demo01.exercise;
import java.util.Scanner;
/*
* 定义一个方法求两个整数范围内所有数的累加和
*/
public class Demo02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个整数");
int m = sc.nextInt();
int n = sc.nextInt();
System.out.println("这两个整数范围内所有整数之和为" + sum(m, n));
//在调用sum2()方法之前，要保证第一个参数小，第二个参数大
if (m>n) {
int t = m;
m = n;
n = t;
}
System.out.println("这两个整数范围内所有整数之和为" + sum2(m, n));
}
/**
* 求两个整数范围内所有数的累加和
* @param num1 接收第一个整数
* @param num2 接收第二个整数
* @return 返回 num1和num2之间所有数的和
*/
public static int sum(int num1,int num2) {
if (num1>num2) {
int t = num1;
num1 = num2;
num2 = t;
}
int sum=0; //保存累加和
for(int x=num1 ;x<=num2 ;x++) {
sum += x;
}
return sum;
}
/**
*
* @param from 范围中的较小数
* @param to 范围中的较大数
* @return
*/
public static int sum2(int from,int to) {
int sum=0; //保存累加和
for(int x=from ;x<=to ;x++) {
sum += x;
}
return sum;
}
}
package com.bjpowernode.demo01.exercise;
import java.util.Scanner;
/*
* 定义一个方法，求两个整数的最大公约数
*/
public class Demo03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个整数");
int x = sc.nextInt();
int y = sc.nextInt();
System.out.println( x + "和" + y + "的最大公约数是" + getGCD3(x, y) );
}
/**
* 求两个整数的最大公约数
* @param m 接收第一个整数
* @param n 接收第二个整数
* @return m和n的最大公约数
*/
public static int getGCD(int m,int n) {
//从n/m遍历到1，找第一个能同时把m和n整除的数
for(int x=m ;x>=1 ;x--) {
if (m%x==0 && n%x==0) {
return x;
}
}
//编译器进行语法检查时，只发现return语句是在条件成立时才会执行到
return 1;
}
public static int getGCD2(int m,int n) {
//从1遍历到m/n，找公约数，保存起来，返回最大的
int gcd = 1; //定义变量保存公约数
for(int x=1 ;x<=m ;x++) {
if (m%x==0 && n%x==0) {
gcd = x;
}
}
return gcd;
}
/**
* 辗转求余法
* m == 18 n == 14
*
* r = m%n; r==4
* m=n; m==14
* n=r; n==4
*
* r = m%n; r==2
* m=n; m==4
* n=r; n=2
*
* r = m%n; r==0 最大公约数为n
* @param m
* @param n
* @return
*/
public static int getGCD3(int m,int n) {
int r = m%n;
while(r != 0) {
m=n;
n=r;
r=m%n;
}
return n;
}
}
package com.bjpowernode.demo01.exercise;
/*
* 定义方法，求任意范围之内所有的素数之和
*/
public class Demo04 {
public static void main(String[] args) {
System.out.println(sumPrime(1, 10));
}
public static int sumPrime(int from,int to) {
int sum=0; //保存素数之和
for(int x=from ;x<=to ;x++) {
if (isPrime(x)) {
sum += x;
}
}
return sum;
}
/**
* 判断一个数是否为素数
* @param x
* @return
*/
private static boolean isPrime(int num) {
if (num<2) {
return false;
}
//如果从2到num-1有某个数能把它整除，就不是素数
for(int i=2 ;i<num ;i++) {
if (num%i==0) {
return false;
}
}
return true;
}
}
package com.bjpowernode.demo01.exercise;
/*
* 定义方法把十进制数转换为十六进制数
*/
public class Demo05 {
public static void main(String[] args) {
System.out.println(toHex(30));
}
public static String toHex(int num) {
String res= ""; //保存十六进制的结果
while(num != 0) {
int r = num%16;
// res = r + res;
res = dToH(r) + res;
num /= 16;
}
return "0x"+res;
}
/**
* 把10~15转换为a~f
*/
public static String dToH(int n) {
if (n<10) {
return ""+n;
}
switch(n) {
case 10:
return "a";
case 11:
return "b";
case 12:
return "c";
case 13:
return "d";
case 14:
return "e";
case 15:
return "f";
}
return "";
}
}
- 定义一个方法，判断一个数是否为回文素数，回文素数是指一个数既是素数又是回文数，如131是一个素数，同时也是一个回文数。编写程序，显示前100个回文素数，每行显示10个
package com.bjpowernode.demo01.exercise;
/*
* 定义一个方法，判断一个数是否为回文素数，回文素数是指一个数既是素数又是回文数
* 如131是一个素数，同时也是一个回文数。编写程序，显示前100个回文素数，每行显示10个
*/
public class Demo06 {
public static void main(String[] args) {
int count=0; //保存回文素数的个数
int num=1;
while( true ) {
if (isPrimePalindromeNumber(num)) {
System.out.print(num + "\t");
count++;
//判断是否需要换行
if (count%10==0) {
System.out.println();
}
//判断是否已经打印100个
if (count>=100) {
break;
}
}
num++;
}
}
public static boolean isPrimePalindromeNumber(int num) {
//一个数既是素数又是回文数
if (isPrime(num) && isPalindrome(num)) {
return true;
}else {
return false;
}
}
/**
* 判断一个数是否是素数
* @param num
* @return
*/
public static boolean isPrime(int num) {
if (num<2) {
return false;
}
//如果从2到num-1有某个数能把它整除，就不是素数
for(int i=2 ;i<num ;i++) {
if (num%i==0) {
return false;
}
}
return true;
}
/**
* 判断一个数是否是回文数
* 回文数是指把一个数逆序之后和原来的数相等
* @param num
* @return
*/
public static boolean isPalindrome(int num) {
if (num == reverse(num)) {
return true;
}
return false;
}
/**
* 定义方法把一个数逆序
* @param num
* @return
*/
private static int reverse(int num) {
int result = 0; //保存逆序逆序之后的数
int r = 0; //余数
while( num != 0 ) {
r=num%10;
result=result*10+r;
num/=10;
}
return result;
}
}
package com.bjpowernode.demo01.exercise;
/*
* 求1！+2！+3！+...+n！的和
*/
public class Demo07 {
public static void main(String[] args) {
System.out.println( sum(1) );
System.out.println( sum(2) );
System.out.println( sum(3) );
System.out.println( sum(4) );
System.out.println( sum(5) );
}
/**
* 求1！+2！+3！+...+n！的和
* @param n
* @return
*/
public static long sum(int n) {
long sum=0; //保存累加和
for(int x=1 ;x<=n ;x++) {
sum += factorial(x);
}
return sum;
}
/**
* 求x的阶乘
* @return
*/
private static long factorial(int x) {
long result = 1;
for(int i=1 ;i<=x ;i++) {
result *= i;
}
return result;
}
}
package com.bjpowernode.demo01.exercise;
/*
* 一个偶数总能表示为两个素数之和
*/
public class Demo08 {
public static void main(String[] args) {
for(int n=10; n<=20 ;n+=2) {
evenEqualsTwoPrime(n);
}
}
public static void evenEqualsTwoPrime(int num) {
for(int x=1 ;x<=num/2 ;x++) {
if (Demo06.isPrime(x) && Demo06.isPrime(num-x)) {
System.out.println(num + "=" + x + "+" + (num-x));
break;
}
}
}
}
- 一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？若一个数能表示成某个整数的平方的形式，则称这个数为完全平方数
package com.bjpowernode.demo01.exercise;
/*
* 一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
* 若一个数能表示成某个整数的平方的形式，则称这个数为完全平方数
*/
public class Demo09 {
public static void main(String[] args) {
int num=1;
while(true) {
if (isCompleteSquareNum(num+100) && isCompleteSquareNum(num+100+168)) {
System.out.println( num );
break;
}
num++;
}
}
//判断某个数是否为完全平方数
private static boolean isCompleteSquareNum(int num) {
for(int x=1 ;x<=num/2 ;x++) {
if (x*x==num) {
return true;
}
}
return false;
}
}
package com.bjpowernode.demo01.exercise;
/*
* 有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁，问第4个人多少岁，他说比第3个人大2岁。
* 问第3个人，又说比第2个人大2岁，问第2个人，比第1个人大2岁，最后问第1个人，他说是10岁。请问第5个人多大？
*/
public class Demo10 {
public static void main(String[] args) {
System.out.println(getAge(5));
}
public static int getAge(int n) {
if (n==1) {
return 10;
}
return getAge(n-1)+2;
}
}
package com.bjpowernode.demo01.exercise;
/*
* 兔子繁殖问题
* 有一对兔子，从第三个月开始，每个月都生一对兔子，新生的兔子也是从第三个月开始，每个月都生一对
* 假设所有兔子都不死，问第n个月有多少对兔子
*
* 月 兔子的数量
* 1 1
* 2 1
* 3 1 + 1 = 2
* 4 2 + 1 = 3
* 5 3 + 2 = 5
* 6 5 + 3 = 8
* 7 8 + 5 = 13
* 8 13 + 8 = 21
* f(n) = f(n-1) + f(n-2)
*/
public class Demo11 {
public static void main(String[] args) {
for(int month=1 ;month<=12 ;month++) {
System.out.println("月份：" + month + ",兔子数" + fabonacci(month));
}
}
public static int fabonacci(int m) {
if (m==1 || m==2) {
return 1;
}
return fabonacci(m-1) + fabonacci(m-2);
}
}
package com.bjpowernode.demo01.exercise;
import java.time.YearMonth;
import java.util.Scanner;
/*
* 打印万年历
*/
public class Demo12 {
public static void main(String[] args) {
//从键盘上接收一个年月
Scanner sc = new Scanner(System.in);
System.out.println("请输入年和月");
int year = sc.nextInt();
int month = sc.nextInt();
//打印这个月的日历
printCalendar(year,month);
}
//打印指定日期的日历
private static void printCalendar(int year, int month) {
System.out.println("日\t一\t二\t三\t四\t五\t六");
//这个月的第一天是星期几
int fromDay = getWeekday(year, month, 1);
//打印这个月第一天之前的空白
for(int i=1 ;i<=fromDay ;i++) {
System.out.print("\t");
}
int count = fromDay; //定义变量统计打印的天数
//打印这个月的每一天
for(int day=1 ;day<=getDaysOfMonth(year, month) ;day++) {
System.out.print(day + "\t");
count++; //统计
if (count%7==0) {
System.out.println();
}
}
}
//返回year年month月day日是星期几，数字0代表星期日，1~6代表星期一~星期六
private static int getWeekday(int year,int month,int day) {
//先计算1900年1月1日到year年month月day日共有多少天
int sum = getDaysFrom19000101(year,month,day);
return sum%7;
}
//计算1900-1-1到year-month-day共有多少天
private static int getDaysFrom19000101(int year, int month, int day) {
int sum = 0;
//1)先计算1900-1-1到year-1年12月31日共有多少天
for(int y=1900 ;y<year ;y++) {
sum += getDaysOfYear(y); //累加每年的天数
}
//2)再加上当年的天数
sum += getDaysToDateInCurrentYear(year,month,day);
return sum;
}
//计算当年从1月1日到指定的month年day日共有多少天
private static int getDaysToDateInCurrentYear(int year, int month, int day) {
int sum = 0;
//累加前month-1个月的天数
for(int m=1 ;m<month ;m++) {
sum += getDaysOfMonth(year,m);
}
//累加当月的天数
return sum + day;
}
//计算year年month月有多少天
private static int getDaysOfMonth(int year, int month) {
switch(month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
return 31;
case 4:
case 6:
case 9:
case 11:
return 30;
case 2:
if (isLeapYear(year)) {
return 29;
}else {
return 28;
}
}
return 0;
}
//计算每年的天数
private static int getDaysOfYear(int y) {
if (isLeapYear(y)) {
return 366;
}
return 365;
}
//判断某一年是否为闰年
private static boolean isLeapYear(int y) {
if ((y%4==0 && y%100!=0) || y%400==0) {
return true;
}
return false;
}
}
1 面向过程和面向对象的区别
1.1 什么是面向过程
面向过程是以解决问题的步骤为核心。各个步骤之间是紧密相关的。
例：“让小明同学去买冰棍”
1）打开教室门
2）向右转
3）向前走15米
4）打开楼道门
5）打开电梯门
6）下到一楼
7）出楼道门
8）向前走200米
9）向左转
10）向前10米
11）进入超市
12）卖冰棍
1.2 什么是面向对象
面向对象是以现实世界中的事物为中心，通过给对象发送消息解决问题。
例：小明.卖冰棍();
2 类和对象的概念
Java是一门面向对象的程序设计语言
2.1 对象的概念
现实世界中客观存在的事物就是对象
万事万物皆对象
2.2 类的概念
把一组对象相同的属性和相同的行为抽象出来就形成了类
类是对一组对象相同属性和相同行为的描述
2.3 类和对象的关系
对象是具体的，类是抽象的
类是对象的模板，对象是类的实例
3 类与对象的定义
在Java中，先定义类，再通过类创建对象
3.1 定义类
[修饰符]class 类名{
//属性；
//行为；
}
1）类的修饰符可以有：public，abstract,final等
2）class是一个关键字，用来定义类
3）类名是程序员起的名字
4）类体需要使用一对大括弧括起来
5）在类体中一般描述所有对象共同的属性和共同的行为
6）属性用变量来保存，行为用方法来表示
package com.bjpowernode.demo02.classdefination.person;
/*
* 定义Person类
* 共同属性（静态特征）：姓名，性别，年龄，身高，体重，身份证号
* 共同行为：吃，喝，睡...
*/
public class Person {
//属性保存在变量中
String name;
String gender; //性别
int height;
int weight;
String personID; //身份证号
//行为使用方法来表示
public void eat() {
System.out.println("人都需要吃饭");
}
public void drink() {
System.out.println("人都需要喝水");
}
}
3.2 创建对象
类名 对象名 = new 类名();
package com.bjpowernode.demo02.classdefination.person;
public class Demo {
public static void main(String[] args) {
//1)创建对象
//类名 对象名 = new 类名();
Person p1 = new Person();
/*
* Person是一个类名，在Java中，类也是一种引用数据类型，Person是一个数据类型
* p1是对戏那个命，实际上就是Person这个类型定义的一个变量名
* 给p1这个对象进行赋值时，new 类名()的返回值赋值给p1变量
* new 运算符会在堆区中分配一块儿存储空间，把这块存储空间的起始地址赋值给变量p1
* p1变量中保存的是堆中内存的一个地址(引用)
*/
//2)类创建了对象之后，对象就可以通过成员运算符(.)访问它的属性和方法
p1.name = "wangYe";
p1.gender = "男";
p1.height = 172;
p1.weight = 60;
p1.personID = "22012219********19";
p1.eat();
p1.drink();
}
}
package com.bjpowernode.demo02.classdefination.computer;
/*
* 计算机类
* 属性：品牌，价格，尺寸，颜色，内存大小，硬盘大小，CPU的主频...
* 行为：开机，关机，运行程序
*/
public class Computer {
//属性保存在变量中
String brand; //品牌
int price;
double screenSize; //屏幕大小
int memorySize;
int diskSize;
double cpuMainFrequency; //CPU主频
public void start() {
System.out.println("电脑开机");
}
public void shutdown() {
System.out.println("电脑关机");
}
public void runGame() {
System.out.println("运行游戏");
}
//在成员方法中，可以直接使用成员变量
//把电脑的属性显示在控制台上
public void showInfo() {
System.out.println("电脑信息：------------------------");
System.out.println("品牌：" + brand);
System.out.println("价格：" + price);
System.out.println("屏幕大小：" + screenSize);
System.out.println("内存大小：" + memorySize);
System.out.println("硬盘大小：" + diskSize);
System.out.println("CPU主频：" + cpuMainFrequency);
}
}
package com.bjpowernode.demo02.classdefination.computer;
/*
* 一个类可以定义多个对象
* 每个对象都有自己的属性和行为
*/
public class Demo {
public static void main(String[] args) {
//创建对象
Computer computer1 = new Computer();
//访问对象的成员
computer1.start();
computer1.runGame();
computer1.shutdown();
computer1.brand = "lenovo";
computer1.cpuMainFrequency = 3.4;
computer1.diskSize = 512;
computer1.memorySize = 16;
computer1.price = 6800;
computer1.screenSize = 15.6;
//把电脑的属性显示在控制台上
System.out.println(computer1.brand);
System.out.println(computer1.cpuMainFrequency);
System.out.println(computer1.diskSize);
System.out.println(computer1.memorySize);
System.out.println(computer1.price);
System.out.println(computer1.screenSize);
//一个类可以创建多个对象
Computer computer2 = new Computer();
//每个对象都有自己的属性和行为
computer2.brand = "dell";
computer2.cpuMainFrequency = 3.2;
computer2.diskSize = 1024;
computer2.memorySize = 8;
computer2.price = 5200;
computer2.screenSize = 17;
computer2.showInfo();
}
}
package com.bjpowernode.demo04.classdefination.dog;
/*在类的一个成员方法中，可以调用另外的成员方法
* 狗类
* 属性：昵称，性别，年龄，身高，体重，品种
* 行为：叫，看门，吃，摇尾巴，显示狗的信息
*/
public class Dog {
String nickname;
String gender;
int age;
String variaty;
public void showInfo() {
System.out.println("狗信息----------------------------");
System.out.println("nickname:" + nickname);
System.out.println("gender:" + gender);
System.out.println("age:" + age);
System.out.println("variaty:" + variaty);
}
//叫唤
public void bark() {
System.out.println("汪~~~~~~~");
}
//狗在吃东西时，会摇尾巴
public void eat() {
System.out.println("狗喜欢吃肉");
shake(); //调用另外一个成员方法
}
//小狗看门时，会叫唤
public void guard() {
System.out.println("狗在看门，生人勿进");
bark(); //调用另外一个成员方法
}
public void shake() {
System.out.println("摇尾巴");
}
}
package com.bjpowernode.demo04.classdefination.dog;
public class Demo {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.age = 3;
myDog.gender = "公";
myDog.nickname = "大黄";
myDog.variaty = "哈士奇";
myDog.showInfo();
myDog.guard();
myDog.eat();
}
}
package com.bjpowernode.demo05.classdefination.rectangle;
/*在不同的包中，可以定义重名的类
*在相同的包中，可以定义重名的类
* 矩形
* 属性：宽，高
* 行为：求周长，求面积
*/
public class Rectangle {
int width;
int height;
public int getArea() {
return width*height;
}
public int getPerimeter() {
return 2*(width+height);
}
public void showInfo() {
System.out.println("矩形信息-------------------");
System.out.println("width:" + width);
System.out.println("height:" + height);
System.out.println("area:" + getArea());
System.out.println("perimeter:" + getPerimeter());
}
}
package com.bjpowernode.demo05.classdefination.rectangle;
public class Demo {
public static void main(String[] args) {
//使用当前包中的Rectangle类
Rectangle rectangle1 = new Rectangle();
rectangle1.width = 10;
rectangle1.height = 5;
rectangle1.showInfo();
//使用java.awt包中的Rectangle类,可以通过使用完整类名
java.awt.Rectangle rectangle2 = new java.awt.Rectangle();
rectangle2.width = 5;
rectangle2.height = 2;
}
}
package com.bjpowernode.demo06.classdefination.person;
/*
* 在定义类时，可以给成员变量赋初值
* 类创建了对象，如果没有给对象的这个成员变量赋值，这个成员变量的值就是在定义时赋的初始值
*/
public class Person {
//属性保存在变量中
String name;
int age;
String gender;
String country = "中国"; //定义成员变量时，可以赋初值
boolean isMarried;
public void showInfo() {
System.out.println("name:" + name);
System.out.println("age:" + age);
System.out.println("gender:" + gender);
System.out.println("country:" + country);
System.out.println("isMarried:" + isMarried);
}
}
package com.bjpowernode.demo06.classdefination.person;
public class Demo {
public static void main(String[] args) {
//通过类定义了对象，如果不给对象的各个变量赋值，对象的各个成员变量会进行默认的初始化
/*
* 数值型数据默认初始化为0
* 字符型数据默认初始化为码值为0的字符
* 布尔类型数据默认初始化为false
* 引用类型数据默认初始化为null
*/
Person p1 = new Person();
p1.showInfo();
Person p2 = new Person();
p2.showInfo();
p2.country = "南非";
p2.showInfo();
}
}
package com.bjpowernode.demo07.classdefination.car;
/*在一个类中，可以使用自定义类型
* 小汽车：
* 属性：品牌，价格，颜色，车型，油耗，排气量，功率
* 行为：启动，停止，显示信息
*/
public class Car {
String carBrand; //汽车品牌
int price;
String color;
String motorcycleType; //车型
double oilConsumption; //油耗
//使用自定义的类型定义成员变量
Engine carEngine; //发动机
public void start() {
System.out.println("小汽车启动，实际上发动机点火");
carEngine.start();
}
public void stop() {
System.out.println("小汽车停止,实际是发动机熄火");
carEngine.stop();
}
public void showInfo() {
System.out.println("汽车信息---------------------");
System.out.println("品牌:" + carBrand);
System.out.println("价格:" + price);
System.out.println("颜色:" + color);
System.out.println("车型:" + motorcycleType);
System.out.println("油耗:" + oilConsumption);
//排量和功率是发动机的排量和工具
System.out.println("排量:" + carEngine.displacement);
System.out.println("功率:" + carEngine.powerSize);
}
}
package com.bjpowernode.demo07.classdefination.car;
public class Demo {
public static void main(String[] args) {
//生产一台小汽车
Car car1 = new Car();
car1.carBrand = "Benz"; //贴标签
car1.color = "red"; //喷漆
car1.motorcycleType = "SUV"; //设置类型
car1.oilConsumption = 15; //标注油耗
car1.price = 1300000; //定价
//先生产一台发动机
Engine engine11 = new Engine();
engine11.displacement = 4.5;
engine11.powerSize = 250;
//把发动机装配到小汽车上
car1.carEngine = engine11;
car1.showInfo();
car1.start();
car1.stop();
}
}
package com.bjpowernode.demo07.classdefination.car;
/*
* 发动机类
*/
public class Engine {
double displacement; //排量
int powerSize; //功率
public void start() {
System.out.println("发动机点火");
}
public void stop() {
System.out.println("发动机熄火");
}
}
