学习视频【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩 (゜-゜)つロ 干杯~-bilibil
psvm自动生成方法
**sout自动生成system out **
public class Hello {
public static void main(String[] args) {
System.out.println("hello sb!");
}
}
单行注释://
多行注释: /**/
**文档注释:JavaDoc / * * * */(用处不大)
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
**强类型语言:**要求变量的使用要严格符合规定,所有变量必须先定义之后才能使用。
(安全、严谨、避免很多错误)
**弱类型语言:**随便定义
Java的数据类型分为两大类:
数据类型+变量名+值 可以使用逗号隔开来声明多个同类型的变量。
转义字符:
**变量:**就是可以变化的量
Java是一种强类型语言,每个变量都必须声明其类型
Java变量程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。
由于Java是强类型语言,所以要进行有些运算的时候,需要用到类型转换。
运算中,不同类型的数据先转化为同一类型,然后进行运算。
从高-低
(要转换的类型)变量名
public class Hello {
public static void main(String[] args) {
int i = 128;
byte b = (byte) i;
System.out.println(i);
System.out.println(b);
}
}
int i = 128;
double b = i;
注意:
精度问题
System.out.println(18.3);//18.7
System.out.println((int)-45.89f);//45
溢出问题
操作比较大的数的时候
int year = 12;
int money = 10_0000_0000;
long total = money*year;
//得到的结果溢出,默认是int,在转换之前就出现问题了。
long total2 = money*(long(year));
**什么是变量:**就是可以变化的量。
Java是一种强类型语言,每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。
数据类型 变量名 = 值
注意:
public class sb{
static int allClicks = 0; //类变量
String str = "hello sb"; //实例变量
public void method(){
int i = 0;//局部变量
}
}
public class sb{
//类变量
static double salary = 2500;//2500默认是int类型 自动转换成了double
//属性:简单理解为变量
//实例变量:从属于对象,如果不进行初始化,这个数值类型的默认值
//布尔值:默认是false
//除了基本类型:其余默认值都是null
String name;
int age;
//mian方法
public static void main(String[] args){
//局部变量:必须声明和初始化值
int i = 23;
System.out.println(i);
sb sb1 = new sb1();
System.out println(sb1.age);
//类变量static
}
//其他方法
public void add(){
}
}
常量:初始化之后不能变动的值。
可以理解为一个特殊的变量。
final 常量名 = 值;(final是个修饰符,不区分前后。)
常量名一般使用大写字符。
()括号的优先级高
**关系运算符的结果是: 正确 错误 布尔值 **
//自增++ 自减--
int a = 3;
int b = a++;//执行完这段代码之后先将3赋值给b,然后再自增。
int c = ++a;//执行这行代码前,先给a自增然后再给c赋值。
//很多运算我们会使用工具类运算double Pow = Math.pow(3,2);System.out.println(Pow);//9.0
&&——逻辑与 两个都为真 结果为真||——逻辑或 其中一个为 结果为真!——取反 真变假 假变真
位运算——看二进制位
&、|、类似于上面的逻辑操作符
^相同为0 不相同为1
~按位取反
左移<< ——相当于把数字乘2、
右移 >>——相当于把数字除2、
字符串连接符
在+号后出现string类型,就会把操作数转化为字符串然后再连接。
在后面的就会正常进行运算。
public class Hello
{
public static void main(String[] args)
{
int a = 10;
int b = 20;
System.out.println(" "+a+b);
System.out.println(a+b+" "); //输出 1020// 30
}
}
三元运算符
x?a:b
x为真 结果为a
x为假 结果为b
public class Hello {
public static void main(String[] args)
{
int score = 20;
String type = score > 60?"及格":"不及格";
System.out.println(type);
}
}
(基本就是新建一个文件夹将两个名称相同的文件分开放,包的本质就是一个文件夹。)
包机制的语法格式为:
package pk1[.pk2[.pk3...]];
一般利用公司域名倒置作为包名(www.baidu.com - com.baidu.www)
为了能够使用某一个包的成员,我们需要在Java程序明确导入该包。使用import语句可以完成此功能。
import package1[.package2...].(classname|*);
是用来生成自己API文档的。
参数信息:
package sb;/*** @author zhaoyuxuan* @version 1.0 * @since 1.8 * * */public class DocJava { String name; /** * @author zhaoyuxuan * @param name * @return * @throws Exception */ public String test(String name) throws Exception{ return name; }}
IDEA、命令行都可以生成javadoc文件。
Scanner获取用户的输入
基本语法:
Scanner s = new Scanner(System.in);
通过next()和nextLine()方法获取输入的字符串,在读取前我们一般需要视同hasNext() 与hasNextLine()判断是否还有输入的数据。
import java.util.Scanner;
public class demo1 {
public static void main(String[] args)
{
//创建一个扫描器对象
Scanner scanner = new Scanner(System.in);
System.out.println("使用next的方式接收:");
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用next方式接收
String str = scanner.next();
System.out.println("输出的内容为:"+str);
}
//凡是IO流的类如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
scanner.close();
}
}
next():
nextLine():
import java.util.Scanner;
public class demo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//从键盘接收数据
int i = 0 ;
float f = 0.0f;
System.out.println("请输入整数:");
if(scanner.hasNextInt())
{
i= scanner.nextInt();
System.out.println("整数数据:"+i);
}
else{
System.out.println("输入的不是整数数据");
}
System.out.println("请输入小数数据:");
if(scanner.hasNextFloat())
{
f = scanner.nextInt();
System.out.println("小数数据:"+f);
}
else{
System.out.println("输入的不是小数数据");
}
}
}
import java.util.Scanner;
public class demo3 {
public static void main(String[] args) {
//我们可以输入多个数字,并求其总和 每输入一个数字用回车确认,用过输入非数字来结束
//输入并输出执行结果。
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
while(scanner.hasNextDouble())
{
double x = scanner.nextDouble();
m = m + 1;
sum = sum +x;
System.out.println("你输入了第"+m+"个数据当前结果sum"+sum);
}
System.out.println(m + "个数字的总和是:"+ sum);
System.out.println(m + "个数字平均数是:"+ (sum/m));
scanner.close();
}
}
if(布尔表达式){ //如果布尔表达式为True将执行的语句}
package struct;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
String s = scanner.nextLine();
if(s.equals("Hello"))
{
System.out.println(s);
}
System.out.println("sb");
scanner.close();
}
}
if(布尔表达式)
{
//如果布尔表达式的值为true
}
else
{
//如果布尔表达式的值为false
}
package struct;
import java.util.Scanner;
public class if_else {
public static void main(String[] args) {
System.out.println("请输入你的成绩");
Scanner scanner = new Scanner(System.in);
//大于等于60分及格,否则不及格
int score = scanner.nextInt();
if(score >= 60)
{
System.out.println("及格");
}
else
{
System.out.println("不及格");
}
}
}
…
if(){ if()}
switch(expression)
{
case value:
//语句
break;
case value:
//语句
break;
......
default:
//
}
switch语句中的变量类型可以是:
package struct;
public class Switch {
public static void main(String[] args) {
char grade = 'D';
switch(grade)
{
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
default:
System.out.println("sb");
}
}
}
(不加break会发生case穿透现象。)
//JDK7的新特性,表达式的结果可以是字符串
//字符的本质还是数字
//反编译
//java——class(字节码文件)
//——反编译(IDEA)
//每一个对象都有自己的一个hashcode
package struct;
public class Switch2 {
public static void main(String[] args) {
String name = "sb";
switch (name)
{
case "sb":
System.out.println("大sb");
break;
default:
System.out.println(123);
}
}
}
反编译
看原码
while(布尔表达式){ //循环内容}
package struct;
public class While01 {
public static void main(String[] args) {
//输出1~100
int num = 1;
while(num <101)
{
System.out.println(num);
num++;
}
}
}
package struct;
public class Whiledemo2 {
public static void main(String[] args) {
//计算1+。。。。100
int sum = 0;
int num = 1;
while(num <=100)
{
sum += num;
num ++;
}
System.out.println(sum);
}
}
do{ //语句}while(布尔表达式)
package struct;
public class Dowhile {
public static void main(String[] args) {
int num = 1;
int sum = 0;
do{
sum += num;
num ++;
}while(num <= 100);
System.out.println(sum);
}
}
区别
package struct;
public class Dowhile {
public static void main(String[] args) {
int a = 0;
while(a < 0)
{
System.out.println(a);
a++;
}
System.out.println("``````````````````````````");
do{
System.out.println(a);
a++;
}while (a< 0);
}
}
}}
for(初始化;布尔表达式;更新){ //代码语句}
package struct;
public class FOr {
public static void main(String[] args) {
for(int i = 1;i <= 100; i++)
{
System.out.println(i);
}
}
}
package struct;
public class FOr {
public static void main(String[] args) {
int oddSum = 0;
int evenSum = 0;
for(int i = 0; i <= 100; i++)
{
if(i%2 != 0)
{
evenSum += i;
}
else
{
oddSum += i;
}
}
System.out.println("偶数的和"+evenSum);
System.out.println("奇数的和"+oddSum);
}
}
package struct;
public class FOR2 {
//练习2,输入1~1000之间的能被5整除的数,并且每行输出3个
public static void main(String[] args) {
for (int i = 1; i < 1000; i++) {
if(i % 5 == 0)
{
System.out.print(i+"\t");
}
if(i %(3*5) == 0)
{
//都可以System.out.println();
System.out.println("\n");
}
}
}
}
println(自动换行)和print
//九九乘法表
package struct;
public class Chengfa {
public static void main(String[] args) {
for (int j = 0; j <= 9; j++) {
for(int i =1; i <=j ; i++)
{
System.out.print(j+"*"+i+"="+(j*i) + "\t");
}
System.out.println("");//换行
}
}
}
增强for——主要用于数组或集合
package struct;
public class Chengfa {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50};
//增强型for
for(int x:numbers)
{
System.out.println(x);
}
System.out.println("123456789");
//或者
for(int i = 0; i < 5 ; i++)
{
System.out.println(numbers[i]);
}
}
}
package struct;
public class Break {
public static void main(String[] args) {
int i = 0;
while(i<100)
{
if(i == 30)
{
break;
}
System.out.println(i);
i++;
}
}
}
package struct;
public class Break {
public static void main(String[] args) {
int i = 0;
while(i<10)
{
i++;
if(i == 3)
{
continue;
}
System.out.println(i);
}
}
}
(JAVA没有)但是有标签
打印三角形5行
package struct;
public class Sanjiao {
public static void main(String[] args) {
for(int i = 1; i <= 5; i++)
{
for(int j = 5 ; j >= i; j--)
{
System.out.print(" ");
}
for(int j = 1 ; j <= i; j++)
{
System.out.print("+");
}
for(int j = 1 ; j < i; j++)
{
System.out.print("+");
}
System.out.println("");
}
}
}
就是其他语言的函数。
package Method;
public class demo1 {
//main方法
public static void main(String[] args) {
int sum = add(1,2);
System.out.println(sum);
}
//加法
public static int add(int a,int b)
{
return a+b;
}
}
修饰符 返回值类型 方法名(参数类型 参数名){ \\\ 方法体 \\\ return 返回值;}
return可以终止方法。
package Method;
public class demo1 {
public static void main(String[] args) {
int result = Max(10,10);
System.out.println(result);
}
public static int Max(int num1,int num2)
{
int max = 0;
if(num1 == num2)
{
System.out.println("num1 = num2");
return 0;
}
if(num1 > num2)
{
max = num1;
}
else
{
max = num2;
}
return max;
}
}
package Method;
public class demo1 {
public static void main(String[] args) {
double result = Max(10.0,20.0);
System.out.println(result);
}
public static int Max(int num1,int num2)
{
int max = 0;
if(num1 == num2)
{
System.out.println("num1 = num2");
return 0;
}
if(num1 > num2)
{
max = num1;
}
else
{
max = num2;
}
return max;
}
public static double Max(double num1,double num2)
{
double max = 0;
if(num1 == num2)
{
System.out.println("num1 = num2");
return 0;
}
if(num1 > num2)
{
max = num1;
}
else
{
max = num2;
}
return max;
}
}
有时你希望运行一个程序的时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
package Method;
public class demo2 {
public static void main(String[] args) {
//args.Length数组长度
for(int i = 0;i <args.length;i++)
{
System.out.println("args["+1+"]:"+args[i]);
}
}
}
package Method;
public class Kbian {
public static void main(String[] args) {
//这个东西的本质就是即将要讲的数组
Kbian kbian = new Kbian();
kbian.test(1,23,4,5,3,2);
}
public void test(int...i)
{
System.out.println(i[0]);
System.out.println(i[1]);
System.out.println(i[2]);
System.out.println(i[3]);
System.out.println(i[4]);
System.out.println(i[5]);
}
}
package Method;
public class Diaoyongkebian {
public static void main(String[] args) {
//调用可变参数方法
printMax(34, 2, 5, 4, 8, 1, 5, 6, 55, 45);
printMax(new double[]{1, 2, 3});
}
public static void printMax(double... numbers) {
if (numbers.length == 0) {
System.out.println("这里什么也没有");
return;
}
double result = 0;
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("最大的数是"+result);
}
}
//计算阶乘
//依次类推,就是将这个的结果传递给下一个,学了C语言之后,在学JAVA的,会感觉简单很多,很容易理解的。
package Method;
public class Self {
public static void main(String[] args) {
System.out.println(f(3));
}
public static int f(int n)
{
if(n == 1) {
return 1;
}
else
{
return n*f(n-1);
}
}
}
(基础部分的最后一个东西)
(JAVA的学习,说白了就是学习一个又一个的类。)
dataType[] arrayRefVar;//首选的方法或者dataType[] arrayRefVar[];//效果相同,但不是首选方法//这个是C和C++的写法,早些年为了上程序员更好的熟悉java。
dataType[] arrayRefVar = new dataType[arraySize];//定义了一个什么类型的数组,就new一个什么类型的数组。
package Array;
public class demo01 {
public static void main(String[] args) {
//变量的类型 变量的名字 = 变量的值;
//数组类型;
int[] nums ;//定义
nums = new int[10];//这里面可以存放10个int类型的数字。
//给数组中的元素赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
//计算所有元素的和
int sum =0;
for(int i= 0 ; i < nums.length ; i++)
{
sum += nums[i];
}
System.out.println("数组nums的和是"+sum);
}
}
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2));
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
public static void main(String[] args) {
int[] a = new int[2];
System.out.printlen(a[2]);
}
package Array;
public class demo03 {
public static void main(String[] args) {
int[] nums = {10,2,33,4,55,6};
//计算数组nums的元素之和
int Sum = 0;
for(int i = 0; i <nums.length;i++)
{
Sum += nums[i];
}
System.out.println("数组nums的和是"+Sum);
System.out.println("#####################");
//找出数组中的 最大值
int Max = 0;
for(int i = 0; i < nums.length;i++)
{
if(nums[i]> Max)
{
Max = nums[i];
}
}
System.out.println("数组nums的最大值是"+Max);
}
}
增强型for-主要用于打印数组中的各个元素,如果要操作其中的元素就没那么适合了。
package Array;
public class demo04 {
public static void main(String[] args) {
int[] nums = { 1,2,3,4,5,6};
for(int x : nums)
{
System.out.println(x);
}
}
}
package Array;
public class demo04 {
public static void main(String[] args) {
int[] nums = { 1,2,3,4,5,6};
//打印数组元素
printfA(nums);
System.out.println();
//反转数组
int[] nums2 = reverse(nums);
printfA(nums2);
}
public static void printfA(int[] Array)
{
for(int i = 0 ; i< Array.length;i++)
{
System.out.print(Array[i]+" ");
}
}
//反转数组
public static int[] reverse(int[] arrays) {
int[] result = new int[arrays.length];
for(int i = 0 , j = result.length-1; i <arrays.length;i++,j--)
{
result[j] = arrays[i];
}
return result;
}
}
int[][] a = new int[4][2];
package Array;
public class demo05 {
public static void main(String[] args) {
//[4][2]
int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
for(int i = 0; i <arrays.length; i++)
{
for(int j = 0; j < arrays[i].length; j ++)
{
System.out.print(arrays[i][j]);
}
System.out.println("");
}
}
}
package arrays;
import java.util.Arrays;
public class demo02 {
public static void main(String[] args) {
//冒泡排序:比较相邻的两个数,如果第 一个数比第二个数大,就交换他们俩个,
int[] nums = {1,23,323,35,2};
//输出原本的数组顺序
System.out.println(Arrays.toString(nums));
int[] sort = sort(nums); //调用完我们自己写的排序方法之后,返回一个排序后的数组
//打印输出nums数组
System.out.println(Arrays.toString(nums));
}
public static int[] sort(int[] arrays)
{
int temp = 0;
//如果数组已经排列好了,我们就没有必要再进行排列了
boolean flag = false;//通过flag标识位来减少没有意义的比较
//外层循环-判断我们要走多少次
for(int i = 0; i < arrays.length-1;i++)
{
//内层循环,比较两个数
for(int j = 0; j < arrays.length-1-i;j++)
{
if(arrays[j] > arrays[j+1])
{
temp = arrays[j];
arrays[j] = arrays[j+1];
arrays[j+1] = temp;
flag = true;
}
if(flag == false)
{
break;
}
}
}
return arrays;
}
}
package arrays;
public class demo08 {
public static void main(String[] args) {
//创建一个 11*11的数组 0-没棋 1-黑棋 2-白棋
int[][] arrays1 = new int[11][11];
arrays1[1][2] = 1;
arrays1[2][3] = 2;
//输出原始的数组
System.out.println("原始的数组是");
for(int[] ints:arrays1)
{
for(int anInt:ints)
{
System.out.print(anInt+"\t");
}
System.out.println();
}
//转化为稀疏数组保存
//获取有效值的个数
int numbers = 0;
for(int i = 0 ; i<11; i++)
{
for(int j = 0; j < 11; j++)
{
if(arrays1[i][j] != 0)
numbers++;
}
}
System.out.println("数组中的有效值一共有"+numbers+"个");
//创建一个稀疏数组的数组
int[][] arrays2 = new int[numbers+1][3];
arrays2[0][0] = 11;
arrays2[0][1] = 11;
arrays2[0][2] = numbers;
//遍历二维数组,将非零的值存进稀疏数组
int count = 0 ;
for(int i = 0; i < arrays1.length;i++)
{
for(int j = 0; j <arrays1[i].length;j++) {
if (arrays1[i][j] != 0)
{
count++;
arrays2[count][0] = i;
arrays2[count][1] = j;
arrays2[count][2] = arrays1[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组");
for(int i = 0; i < arrays2.length;i++)
{
System.out.println(arrays2[i][0]+"\t"+ arrays2[i][1]+"\t"+arrays2[i][2]+"\t");
}
System.out.println("========");
System.out.println("还原");
//读取稀疏数组
int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];
//给其中的元素还原它的值
for(int i = 1; i <arrays2.length;i++)
{
arrays3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];
}
//打印
System.out.println("输出原始的数组");
for(int[] ints:arrays3)
{
for(int anInt:ints)
{
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
package FACE;
public class demo02 {
public static void main(String[] args) {
//函数调用的两种方法
System.out.println(new demo02().Add(3,4));//非静态
System.out.println(Bdd(3,4));//静态
}
public static int Bdd(int a ,int b)
{
return a+b;
}
public int Add(int a ,int b)
{
return a+b;
}
}
package FACE;
//值传递 无法改变
public class demo03 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
new demo03().change(a);
System.out.println(a);
}
public void change(int a )
{
a = 10;
}
}
package FACE;
//引用传递:传递一个对象,本质还是值传递。
public class demo04 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
demo04.Change(person);
System.out.println(person.name);
}
public static void Change(Person person) {
//person是一个具体的类 指向一个人 Person person = new Person();这是一个具体的人 可以改变属性
person.name = "傻逼";
}
}
class Person{
String name;//默认为Null
}
(一个对象就相当于C语言里面的结构体)
//类是一个抽象的模板, 通过给它赋值来将它具体化
package FACE;
public class demo05 {
//属性:字段
String name ; //null
int age ; //0
//方法
public void study()
{
System.out.println(this.name+"在学习");
}
}
//具体化
package FACE;
//一个项目应该只存一个main方法
public class demo06 {
public static void main(String[] args) {
//类:抽象的,实例化。
//类实例化后会返回一个自己得对象
//demo05对象就是一个student类的具体实例!
demo05 xiaoming = new demo05();
demo05 xiaohong = new demo05();
xiaoming.name = "sb";
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
package opp;
public class Person {
//一个类即使什么都不写,也会存在一个方法
//显式定义的构造器
String name;
//实例化初始值
//使用new关键字,本质上实在调用构造器
public Person()
{
}
//有参构造:一旦定义了有参构造,无参定义就必须显示定义
public Person(String name)
{
this.name = name;
}
}
/*
*构造器:
* 1必须和类名相同
* 2没有返回值
* 作用
* 1new本质在调用构造方法
* 2,初始化对象的值
* 注意点:
* 1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
* Alt+insert*/
package opp;
public class Application {
public static void main(String[] args) {
//使用new关键词实例化了一个对象
Person person = new Person("sb");
System.out.println(person.name);
}
}
package opp;
import opp.Pet;
public class App {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
package opp;
public class Pet {
public String name;
public int age;
//无参构造
public void shout()
{
System.out.println("叫了一声");
}
}
package opp;
public class Summary {
public static void main(String[] args) {
/**
* 1.类与对象
* 类是一个模板:抽象,对象是一个具体的实例
* 2.方法
* 定义、调用!
* 3.对象的引用
* 引用类型:基本类型(8)
* 对象是通过引用来操作的:栈--》堆(地址)
* 4.属性:字段:Field 成员变量
* 默认初始化值:
* 数字: 0 0.0
* char: u0000
* bool:false(默认)
* 引用:
* null
* 修饰符 属性类型 属性名 = 属性值!
* 5.对象的创建和使用
* -必须使用new关键字创造对象,构造器Person sb = new Person();
* -对象的属性 sb.name;
* -对象的方法 sb.sleep();
* 6.类
* 静态的属性
* 动态的行为
*/
/
}
}
alt+insert
package opp;
public class Student {
//属性私有
private String name;
private int id;
private char sex;
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get获得这个数据
public String getName()
{
return this.name;
}
//set给这个数据设置值
public void setName(String name)
{
this.name =name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120 || age<0)
{
this.age = 3;
}
else{
this.age = age;
}
}
}
package opp;
import opp.Student;
public class App2 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("sb");
System.out.println(s1.getName());
s1.setAge(15);
System.out.println(s1.getAge());
}
}
package opp;
import opp.Student;
public class App2 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("sb");
System.out.println(s1.getName());
s1.setAge(15);
System.out.println(s1.getAge());
}
}
判断两个方法是否相同看-方法名-参数
子类继承了父类就会拥有父类的全部方法。
父类public的方法可以继承,private的方法无法继承。
Ctrl+h——显示继承的关系
在JAVA中所有的类都默认直接或间接继承object类
super注意点
和this对比
方法重写:
重写需要有继承关系,子类重写父类的方法
重写,子类的方法和父类必要一致,方法体不同。
为什么要重写?
Alt+Insert:override
package DuoTai;
public class Student extends Person {
@java.lang.Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
package DuoTai;
import DuoTai.Student;
import DuoTai.Person;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了
//父类的引用指向子类
//Student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
//子类重写了父类的方法,执行子类的方法
s2.run();
s1.run();
//对象能执行那些方法只要看对象左边的类型,和右边关系不大
((Student)s2).eat();//强制类型转换 高转低
s1.eat();
}
}
/*
1.多态是方法的多态,属性没有多态
2.父类和子类有联系 类型转换异常 ClassCastException
3.多态存在的条件:有继承关系,方法需要重写(否则就是调用各自的方法,那就没有任何区别了)
4. 父类的引用指向子类对象 Father f1 = new Son();
Static是静态方法属于类,不属于实例
final常量
private方法:都没有重写 哪来的多态呢
*/
instanceof类型转换(与JAVA基础差不多,只是这里的类型转换指的是引用类型的转换)
判断一个对象是什么类型 instanceof,判断两个类之间是否存在父子关系。
package DuoTai;import DuoTai.Student;import DuoTai.Person;import DuoTai.Teacher;public class Application { public static void main(String[] args) { //System.out.println(x instanceof y); //就是看x和y之间有没有父子,没有则报错 //Object - Person - Student Object object = new Student(); System.out.println(object instanceof Student); System.out.println("###########"); Student student = new Student(); System.out.println(student instanceof Person); }}
static关键字详解
package Static;
//static加在方法上叫静态方法,加在属性上叫静态属性
public class Student {
private static int age;//静态变量
private double score;//非静态变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
//静态可以这样调用
System.out.println(Student.age);
new Student().run();
//非静态
System.out.println(s1.age);
go();
}
}
package Static;
public class Person {
//赋初始值
{
//匿名代码块(不建议这么写)
System.out.println("匿名代码块");
}
//只执行一次
static {
//静态代码块
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("##############");
Person person2 = new Person();
}
}
/**
* 静态代码块
* 匿名代码块
* 构造方法
*/
//输出
静态代码块
匿名代码块
构造方法
##############
匿名代码块
构造方法
package Static;
//静态导入包
import static java.lang.Math.random;
public class demo01 {
public static void main(String[] args) {
System.out.println(random());//代替Math,random
}
}
//final表示该类不能被继承
package Static;
//abstract抽象类
//extends单继承 接口多继承(例如插座可以插很多个插头)
public abstract class demo02 {
//约束,有人帮我们实现
//抽象方法 只有方法名字 没有方法实现
//抽象类的所有方法,继承了他的子类都要实现它的方法
//除非它的子类也是abstract,那就让它的子子类去实现......
public abstract void doSomething(){
}
/**
*不能new这个抽象类,只能靠子类去实现它,
*抽象类中可以写普通的方法
* 抽象方法必须在抽象类中
* 抽象的抽象 约束
* 存在的意义:抽象出来 提高开发效率 后期可扩展性比较高
* /
/
}
声明类的关键字是class,声明接口的关键字是interface
package dem0o01;
//interface定义的关键字:接口都需要实现类
//抽象的思维-架构师
public interface UserService {
//接口中的所有定义其实都是抽象的public
//接口中定义常量
//一般来说是没有在接口中定义常量的
public static final int AGE = 99;
//返回类型+方法
//定义的方法都是public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
作用:
package dem0o01;
public class Outer {
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
package dem0o01;
public class Application {
public static void main(String[] args) {
//new-外部类
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
}
}
package dem0o01;
public class Outer {
//局部内部类
public void method(){
class Inner{
}
}
}
//一个java类中只能有一个public class
//但能有多个class类
class A{
}
package dem0o01;
public class test {
public static void main(String[] args) {
// Apple apple = new Apple();
//没有名字初始化类-就是匿名初始化类
//不用将实例保存到变量中
new Apple().eat();
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
}
(上面一些奇奇怪怪的创建类的方法不推荐使用,否则这个代码就只有你能看懂啦。)
(快捷键ctrl+alt+t快速选择语句将所选中的语句包裹起来)
import sun.security.mscapi.CPublicKey;
import javax.naming.directory.AttributeInUseException;
public class Abnormal {
public static void main(String[] args) {
int a = 2;
int b = 0;
//监控异常
try {//try监控区域
System.out.println(a/b);
}catch(ArithmeticException e){//捕获异常/里面的参数是捕获错误的类型
System.out.println("程序出现异常啦");
}finally{//处理善后工作
System.out.printf("finally");
}
}
public void test(int a,int b)
{
//假设在这个方法中处理不了异常,在方法上抛出异常。
//主动抛出异常throw throws
if(b == 0){
throw new ArithmeticException();//主动抛出异常,一般在方法中使用
}
}
}
public class demo01 extends Exception {
//传递数字>10;
private int detail;
public demo01(int a ){
this.detail = a;
}
//toString:异常的打印信息
//实现了一个自定义的异常
@Override
public String toString() {
return "demo01{" +
"detail=" + detail +
'}';
}
}
//测试类
public class Test {
//可能会存在异常的方法
static void test(int a) throws demo01{
System.out.println("传递的参数为:"+a);
if(a > 10)
{
throw new demo01(a);//抛出
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
}catch (demo01 e)
{
System.out.println("MyException=>"+e);
}
}
}