- 博客(87)
- 收藏
- 关注
RSS订阅翻译 我的第一个jdbc程序
package com.kuang.lesson01; import java.sql.*; //我的第一个jdbc程序 public class jdbcFirstDemo01 { public static void main(String[] args) throws ClassNotFoundException, SQLException { //1.加载驱动 //Class.forName(“com.mysql.jdbc.Driver”); //固定写法,加载驱动 5.0版jdbc Class.
2021-05-18 19:53:08
127
翻译 Test
package exception.Demo01; public class Test { public static void main(String[] args) { int a = 1; int b = 0; //假设要捕获多个异常: 从小到大! try { //try监控区域 // System.out.println(a/b); new Test().a(); } catch (Error e) { //catch 捕获
2021-04-26 02:11:59
133
翻译 Outer
package OOP.Demo11; public class Outer { public void method(){ class inner{ public void in(){ } } } } //一个java类中可以有多个class类,但是只能有一个public class类 class A{ public static void main(String[] args) { } } /* private int id=10; public void out(){
2021-04-26 00:56:48
132
翻译 Test
package OOP.Demo11; public class Test { public static void main(String[] agrs){ //没有名字初始化类,不用将实例保存到变量中 new Apple().eat(); UserService userService= new UserService(){ @Override public void hello() { } }; } } class Apple{ publi
2021-04-26 00:54:18
180
翻译 implements 接口
package OOP.Demo10; //抽象类: extends~ //类 可以实现接口 implements 接口 //实现了接口的类,就需要重写接口中的方法~ public class UserServiceImpl implements UserService,TimeService { @Override public void run(String name) { } @Override public void delete(String name) { } @Override pub
2021-04-26 00:52:21
226
翻译 UserService
Demo09 //interface 定义的关键字 接口都需要实现类 public interface UserService { //常量~ public static final int AGE=99; //接口中所有定义其实都是抽象的 public abstract void run(String name); void delete(String name); void update(String name); void query(String name); } ...
2021-04-26 00:51:08
560
翻译 接口小总结
Demo09 作用: 1.约束 2.定义一些方法 3.public abstract 4.public static final 5.接口不能被实例化,接口中没有构造方法 6.implements可以实现多个接口 7.必须要重写接口中的方法 8.总结博客
2021-04-26 00:50:20
209
翻译 A
package OOP.Demo09; //抽象类的方法继承了它的子类,都必须要实现它的方法~ 除非~ public class A extends Action { @Override public void dosomething() { } }
2021-04-26 00:49:14
147
翻译 Action
package OOP.Demo09; import java.util.concurrent.ArrayBlockingQueue; //abstract 抽象类: 类 extends: 单继承~ (接口可以多继承) public abstract class Action { //约束~有人帮我们实现~ //abstract ,抽象方法,只有方法名字,没有方法实现. public abstract void dosomething(); //1.不能new这个抽象类,只能靠子类去实现它: 约束! //
2021-04-26 00:48:48
96
翻译 Test
Demo08 package OOP.Demo08; //静态导入包 import static java.lang.Math.random; // 设置一次之后,就不用每次都需要类名前缀了 public class Test { public static void main(String[] args) { System.out.println(Math.random()); System.out.println(random()); //不用类名,直接使用随机数, } } ...
2021-04-26 00:47:38
98
翻译 Student
Demo08 package OOP.Demo08; public class Student { private static int age; //静态的变量 private double score; //非静态变量 public void run(){ go(); } public static void go(){ } public static void main(String[] args) { go(); /* Student s1 = new Stu
2021-04-26 00:45:18
153
翻译 2021-04-25
Demo08 package OOP.Demo08; public class Person { //2 : 赋初值~ { //代码块 (匿名代码块) System.out.println(“匿名代码块”); } //1: 只执行一次~ static { //静态代码块 System.out.println("静态代码块"); } //3 public Person(){ System.out.println("构造方法"); } public static void mai
2021-04-25 20:57:15
85
翻译 Person
Demo08 package OOP.Demo07; public class Student extends Person{ public void go(){ System.out.println("go"); } } /* //类型之间的转化: 父 子 //高 低 Person obj = new Student(); //student 将这个对象转换为Student 类型,我们就可以使用Student类型的方法了!
2021-04-25 20:56:02
166
原创 Person
Demo06 package OOP.Demo06; public class Student extends Person{ @Override public void run() { System.out.println("son"); } public void eat(){ System.out.println("ear"); } }
2021-04-25 01:41:31
118
原创 Application
Demo06 package OOP; import OOP.Demo06.Person; import OOP.Demo06.Student; //静态的方法和非静态的方法区别很大! //静态方法://方法的调用只和左边,定义的类型有关 //非静态:重写 public class Application { public static void main(String[] args) { // 一个对象的实际类型是确定的 // new Student(); // new Perso
2021-04-25 01:40:56
106
原创 Person
Demo06 package OOP.Demo06; import org.w3c.dom.ls.LSOutput; public class Person { public void run(){ System.out.println("run"); } } /* 多态的注意事项: 1.多态是方法的多态,属性没有多态 2.父类和子类,有联系 类型转换异常! ClassCastException! 3.存在条件: 继承条件: 方法需要重写,父类引用指向子类对象! father f1=new so
2021-04-25 01:40:25
98
翻译 Student
Demo05 package OOP.Demo05; //学生 is 人:派生类 ,子类 //子类继承了父类,就会拥有父类的全部方法! public class Student extends Person { //隐藏代码:调用了父类的无参构造 //super(); //调用父类的构造器,必须要在子类构造器的第一行 public Student(){ System.out.println(“Student无参执行了”); } private String name="qinjiang"; publi
2021-04-25 00:12:49
110
原创 Person
Demo public class Person { public Person(){ System.out.println(“Person无参执行了”); } protected String name="kuangshen"; //私有的东西无法被继承! public void print(){ System.out.println("Student"); } } /* //public //protected //default //private private int money=10_0
2021-04-25 00:11:57
103
原创 B
Demo05 package OOP.Demo05; //重写都是方法的重写,和属性无关 public class B { public void test(){ System.out.println("B=>test()"); } }
2021-04-25 00:11:23
122
原创 A
Demo05 package OOP.Demo05; //继承 public class A extends B { //Override 重写 @Override //注解: 有功能的注释 public void test() { System.out.println("A=>test()"); } }
2021-04-25 00:11:00
92
原创 super和this与重写笔记
Demo05 super 注意点: 1.super调用父类的构造方法,必须在构造方法的第一个 2.super 必须只能出现在子类的方法或者构造方法中 3.super和this不能同时调用构造方法! Vs this: 代表的对象不同: this:本身调用者这个对象 super:代表父类对象的应用 前提 this: 没被继承也可以调用 super:只能在继承条件才可以使用 构造方法 this(); 本类的构造 super(): 父类的构造 重写:需要有继承关系,子类重写父类的方法! 1.方法名必须相同 2.参数
2021-04-25 00:10:08
102
原创 Student
Demo04 package OOP.Demo04; //类 private:私有 public class Student { //属性私有 private String name; //名字 private int id; //学号 private char sex; //性别 private int age; //年龄 //提供一些可以操作这个属性的方法! //提供一些public 的get,set方法 //get 获得这个数据 public String getName(){ ret
2021-04-24 21:04:23
1300
原创 Pet
package OOP.Demo03; public class Pet { public String name; public int age; public void shout(){ System.out.println("叫了一声"); } } /* package OOP.Demo03; public abstract class Application { public static void main(String[] args) { Pet dog = new Pet(); dog.
2021-04-24 15:05:26
114
原创 简单的小结类与对象
/* 1.类与对象 类是一个模板:抽象,对象是一个具体的实例 2.方法 定义,调用! 3.对应的引用 引用类型: 基本类型(8) 对象是通过引用来操作的: 栈--->堆 4.属性:字段Field 成员变量 默认初始化: 数字: 0 0.0 char: u0000 boolean: false 引用: null
2021-04-24 15:04:57
91
原创 Student
package OOP.Demo02; //学生类 public class Student { //属性: 字段 String name; int age; //方法 public void study(){ System.out.println(this.name+"学生在学习"); } }
2021-04-24 14:06:36
109
原创 Person
package OOP.Demo02; public class Person { //一个类即使什么都不写,它也会存在一个办法 //显示的定义构造器 String name; int age; //Alt+Insert 构造生成快捷键 //1.使用new关键字,本质是在调用构造器 //2.用来初始化值 public Person (){ this.name="qinjiang"; } //有参构造:一旦定义了有参构造,无参就必须显示定义 public Person(String na
2021-04-24 14:04:41
123
翻译 Demo05
package OOP.Demo01; //引用传递:对象,本质还是值传递 //对象,内存! public class Demo05 { public static void main(String[] args) { Perosn perosn = new Perosn(); System.out.println(perosn.name); //null Demo05.change(perosn); System.out.println(perosn.name); //老师 } public stati
2021-04-24 14:03:58
144
翻译 Demo04
package OOP.Demo01; //值传递 public class Demo04 { public static void main(String[] args) { int a=1; System.out.println(a); Demo04.change(a); System.out.println(a); } //返回值为空 public static void change(int a){ a=10; } }
2021-04-24 14:03:45
122
翻译 Demo03
package OOP.Demo01; public class Demo03 { public static void main(String[] args) { //实际参数和形式参数的类型要对应! int add=Demo03.add(12,13); System.out.println(add); } public static int add(int a,int b){ return a+b; } }
2021-04-24 14:02:34
119
翻译 Demo02
package OOP; public class Demo02 { public static void main(String[] args) { //和类一起加载的 public static void a(){ // b(); } //类实例化 之后才存在 public void b(){ } } }
2021-04-24 14:02:03
106
翻译 Demo01
package OOP; //Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { } /* public 修饰符 公共的,所有人都可以访问 String 返回的类型 字符串 sayHello 方法名 return 返回的内容 修饰符 返回值的类型 方法名(...){ // 方法体 return 返回值; } */ public String sayHello(){ return
2021-04-23 00:53:43
138
原创 ArrayDemo08
package array; public class ArrayDemo08 { public static void main(String[] args) { //1.创建一个二维数组 11*11 0:没有棋子, 1:黑棋, 2白棋 int[][] array1 = new int[11][11]; array1[1][2] = 1; array1[2][3] = 2; //输出原始的数组 System.out.println(“输出原始的数组”); for (int[] ints : ar
2021-04-23 00:26:30
131
原创 ArrayDemo07
package array; import java.util.Arrays; public class ArrayDemo07 { //冒泡排序 //1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置 //2.每一次比较,都会产生出一个最大,或最小的值 public static void main(String[] args) { int[] a={1,2,854,15,584,4513,4154,4}; int [] sort=sort(a); //调用完成我们自己写的排
2021-04-23 00:26:03
118
原创 ArrayDemo06
package array; import java.util.Arrays; public class ArrayDemo06 { public static void main(String[] args) { int [] a ={1,2,1515,11,165161,11}; System.out.println(a); //[I@50cbc42f //打印数组元素 Arrays.toString(a) System.out.println(Arrays.toString(a));
2021-04-23 00:24:45
102
原创 ArrayDemo05
package array; public class ArrayDemo05 { public static void main(String[] args) { //[4][2] /* 1,2 array [0] 2,3 array [1] 3,4 array [2] */ int[][] array ={{1,2},{2,3},{3,4},{4,5}}; for(int i=0;i<array.length;i++){ for (int j = 0; j < array[i].length
2021-04-23 00:24:24
101
原创 ArrayDemo04
package array; public class ArrayDemo04 { public static void main(String[] args) { int[] arrays = {1, 2, 3, 4, 5}; // //JDK1.5以上 没有下标 // for (int array : arrays) { // System.out.println(array); // printArray(arrays); int[]
2021-04-23 00:22:59
123
原创 ArrayDemo03
package array; public class ArrayDemo03 { public static void main(String[] args) { int[] arrays={1,2,3,4,5}; //打印全部的数组元素 for(int i=0;i<arrays.length;i++){ System.out.println(arrays[i]); } System.out.println("===================
2021-04-23 00:22:34
98
原创 ArrayDemo02
package array; public class ArrayDemo02 { public static void main(String[] args) { //静态初始化 int[] a={1,2,3,4,5,6,7,8}; System.out.println(a[0]); //动态初始化:包含默认初始化 int[] b=new int[10]; b[0]=10; b[9]=10; System.out.println(a[0]); System.
2021-04-23 00:21:12
101
原创 ArrayDemo01
package array; public class ArrayDemo01 { //变量的类型 变量的名字 =变量的值; //数组类型 public static void main(String[] args){ int [] nums; //1定义 nums=new int[10]; //这里面可以存放10个int数字 // int[] nums=new int[10] 可以一起定义创建 nums[0]=1; //创建一个数组 nu
2021-04-23 00:20:45
168
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人